﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DAL;
using System.Data;
using System.IO;
using System.Configuration;
using System.Transactions;
using System.Data.Linq;
using System.ComponentModel;
using UtilityExtensions;
using System.Web;
using System.Web.SessionState;


namespace BOL
{
    [Serializable]
    public class OrdenCompraBL
    {
        public string ORDENCOMPRAITEMINFO { get { return "OrdenCompraItemInfo";} }

        
        private DAL.Menu ordenCompraRead = DbUtil.Db.Menus.Single(p => p.idInternal == 106);
        private DAL.Menu ordenGastoRead = DbUtil.Db.Menus.Single(p => p.idInternal == 107);
        
#region "CRUD"

        public int addCompra( dbGestionDataContext _db,
                            int?	idComparativoProvSelec,
                            int	idProveedor,
                            DateTime fechaEmision,
                            DateTime fechaContrato,
                            DateTime FechaEntrega,
                            int	idFormaPago,
                            int	idMoneda,
                            string	moneda,
                            int?	idComparativo,
                            bool	bitInclIGV,
                            decimal igv,
                            string	observaciones,
                            int	    idObra,
                            string  centroCosto,
                            int	    idEstructuraCompras,
                            string	direccionEntrega,
                            string	atencionEntrega,
                            string	direccionEntComprobante,
                            bool bitAnticipo,
                            string observacionInter,
                            DataSet entityList
            )
            
        {
           
            using (TransactionScope ts = new TransactionScope())
            {
                

                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                //--------------------
                bool acceso = new FormularioAcceso().VerificarAcceso(_db,
                    idEmpleadoEmisor,
                    3,
                    idObra,
                    2);
                //-------------------------
                


                Empleado empleadoEmision = _db.Empleados.Single(p => p.idInternal == idEmpleadoEmisor);
                Proveedor proveedor = _db.Proveedors.SingleOrDefault(p => p.idInternal == idProveedor);

                if (proveedor == null)
                {
                    throw new Exception("Verifique Proveedor");
                }
 
                // obtenemos el Amacen a donde se genera su ingreso
                int idAlmacen=0;
                var q=_db.Almacens.Where(p=>p.idObra==idObra);
                    if (q.Count()>0) {idAlmacen=q.First().idInternal;}
                    else { throw new Exception("No existe Almacen Para la Obra"); }
               


                //verificamos el tipo de cambio del dia antes de generacion del OC
                // necesario para asegurar la recepcion
                Moneda monedaAct = _db.Monedas.Single(p => p.idInternal == 4);
                decimal tp=monedaAct.getTipoCambio(_db, fechaEmision);

                DAL.OrdenCompra db = new DAL.OrdenCompra();


                db.Add(_db,
                    1,
                    null,
                    db.getCorrelativoCompra(_db,idObra),
                   idComparativoProvSelec,
                    idAlmacen,
                    proveedor.descripcion,
                    idProveedor,
                    proveedor.contacto,
                    proveedor.ruc,
                    empleadoEmision.descripcion,
                    idEmpleadoEmisor,
                    fechaEmision,
                    fechaContrato,
                    FechaEntrega,
                    idFormaPago,
                    idMoneda,
                    moneda,
                    igv,
                    idComparativo,
                    idMoneda == 3 ? 1 : tp,
                    observaciones,
                    idObra,
                    idEmpleadoEmisor,
                    centroCosto,
                    idEstructuraCompras,
                    direccionEntrega,
                    atencionEntrega,
                    direccionEntComprobante,
                    bitInclIGV,
                    11,
                    bitAnticipo,
                    observacionInter);

                int contador = 0;
                int clase = 0;
                Insumo objClase = new Insumo();

                DataSet dsDiferencias = new DataSet();


                if (entityList.Tables["OrdenCompraItemInfo"].Rows.Count == 0)
                {
                    throw new Exception("No debe existir Ordenes de Compra sin Items");
                }

                if (entityList.HasChanges())
                {
                    dsDiferencias.Merge(entityList.GetChanges());

                    foreach (DataRow drw in dsDiferencias.Tables["OrdenCompraItemInfo"].Rows)
                    {
                        if (drw.RowState == DataRowState.Added)
                        {
                            //siempre se verifica del origen;
                            Insumo insumo = _db.Insumos.Single(p => p.idInternal == drw.Field<int>("idInsumo"));

                            //if (drw.idInternal == 0)
                            //{
                            //    continue;
                            //}
                            if (insumo.idPadre == 5571)
                            {
                                throw new Exception("el Insumo :" + insumo.descripcion + " debe ser clasificado ");
                            }
                            contador++;

                            OrdenCompraItem ordenCompraItem = new OrdenCompraItem();
                            var re = from a in _db.Insumos
                                     where a.idInternal == insumo.idInternal
                                     select a.Insumo1.Insumo1.Insumo1;
                            if (contador == 1)
                            {

                                objClase = re.First();
                                clase = objClase.idInternal;
                            }
                            else
                            {
                                if (clase != re.First().idInternal)
                                {
                                    throw new Exception("La Estructura del Insumo:" + insumo.descripcion + "  no pertenece a la clase " + objClase.descripcion + "Genere  para este recurso otra Orden de Compra");
                                }
                            }
                            int? compSelcProv = drw.Field<int>("idComparativoItemSelecPrv");
                            ordenCompraItem.Add(_db,
                                (compSelcProv == 0 ? null : compSelcProv),
                            db.idInternal,            //OC
                            insumo.idInternal,
                            insumo.codigo,
                            insumo.descripcion,
                            insumo.InsumoUnidad.abreviacion,
                            drw.Field<decimal>("descuento"),
                            drw.Field<decimal>("cantidad"),
                            drw.Field<decimal>("precioInclIGV"),
                            drw.Field<decimal>("precioNoIGV"),
                            drw.Field<decimal>("IGVItem"),
                            drw.Field<decimal>("subMontoIGV"),
                            drw.Field<decimal>("subMonto"));




                        }

                    }
                }

 
                db.updateTotales(_db,true);

                if (idComparativo != null)
                {
                    Comparativo comparativo =
                     _db.Comparativos.Single(p => p.idInternal == idComparativo);
                        comparativo.updateUsoFromOrdenCompra(_db);
                }
                
                

                ts.Complete();

                return db.idInternal;
            }

        }



        public int UpdateCompra(  int idOrdenCompra,
                            int	idProveedor,
                            DateTime fechaEmision,
                            DateTime fechaContrato,
                            DateTime FechaEntrega,
                            int	idFormaPago,
                           
                            int	idMoneda,
                            string	moneda,
                            int?	idComparativo,
                            bool	bitInclIGV,
                            decimal igv,
                            string	observaciones,
                            string  centroCosto,
                            int	    idEstructuraCompras,
                            string	direccionEntrega,
                            string	atencionEntrega,
                            string	direccionEntComprobante,
                            bool bitAnticipo,
                              string observacionInter,
                            DataSet entityList )
        {
            
            using (TransactionScope ts = new TransactionScope())
            {

            
                dbGestionDataContext _db =
                    new dbGestionDataContext(Parametros.strConnString);

                OrdenCompra ordenCompra = _db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);

                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                //--------------------
                bool acceso = new FormularioAcceso().VerificarAcceso(_db,
                    idEmpleadoEmisor,
                    3,
                    ordenCompra.idObra.Value,
                    2);
                //-------------------------     
                Empleado empleado = _db.Empleados.Single(p => p.idInternal == idEmpleadoEmisor);
                Proveedor proveedor = _db.Proveedors.Single(p => p.idInternal == idProveedor);
                //Comparativo comparativo =
                 //_db.Comparativos.Single(p => p.idInternal == idComparativo);
                //ComparativoProveedor cp =
                  //  _db.ComparativoProveedors.Single(p => p.idinternal == idComparativoProvSelec);


                //verificamos el tipo de cambio del dia antes de generacion del OC
                // necesario para asegurar la recepcion
                Moneda monedaAct = _db.Monedas.Single(p => p.idInternal == 4);
                decimal tp = monedaAct.getTipoCambio(_db, fechaEmision);

                // la orden de compra guarda el tipo de cambio del comparativo;
                //db.numDocumento = db.getCorrelativo(_db, idObra);

                ordenCompra.SetUpdateCompra(_db,
                                             proveedor.descripcion,
                                             proveedor.contacto,
                                             proveedor.ruc,
                                             empleado.descripcion,
                                             idEmpleadoEmisor,
                                             fechaEmision,
                                             fechaContrato,
                                             FechaEntrega,
                                             idFormaPago,
                                             idMoneda,
                                             moneda,
                                              idMoneda == 3 ? 1 : tp,
                                             idEstructuraCompras,
                                             direccionEntrega,
                                             atencionEntrega,
                                             direccionEntComprobante,
                                             observaciones,
                                             idEmpleadoEmisor,
                                             bitAnticipo,observacionInter);
                
                DataSet dsDiferencias = new DataSet();

                if (entityList.HasChanges())
                {
                    dsDiferencias.Merge(entityList.GetChanges());

                    foreach (DataRow drw in dsDiferencias.Tables["OrdenCompraItemInfo"].Rows)
                    {
                        if (drw.RowState == DataRowState.Modified)
                        {
                            //siempre se verifica del origen;
                            Insumo insumo = _db.Insumos.Single(p => p.idInternal == drw.Field<int>("idInsumo"));

                            OrdenCompraItem ordenCompraItem =
                                _db.OrdenCompraItems.
                                Single(p => p.idInternal == drw.Field<int>("idInternal"));

                             if (ordenCompra.Obra.incluyeIGV.Value)
                                {
                                    ordenCompraItem.SetUpdateTotalSIIGV(_db, drw.Field<decimal>("subMontoIGV"));
                                }
                                else
                                {
                                    ordenCompraItem.SetUpdateTotalNOIGV(_db, drw.Field<decimal>("subMonto"));
                                }

                            var w= _db.EstructuraCostoItems.SingleOrDefault(p=>p.idOrdenCompraItemRef==ordenCompraItem.idInternal);
                            if (w!=null)
                            {
                                throw new Exception ("el Item {0} de la Orden de Compra se encuentra utilizado en la estructura de compras:{1}".Fmt(ordenCompraItem.codigo,w.EstructuraCosto.descripcion ));
                            }
                            _db.SubmitChanges();
                           
                        }

                        if (drw.RowState == DataRowState.Deleted)
                        {
                            drw.RejectChanges();

                            OrdenCompraItem erol = _db.OrdenCompraItems.Single(p => p.idInternal == drw.Field<int>("idInternal"));
                          

                              var w= _db.EstructuraCostoItems.SingleOrDefault(p=>p.idOrdenCompraItemRef==erol.idInternal);
                            if (w!=null)
                            {
                                throw new Exception ("el Item {0} de la Orden de Compra se encuentra utilizado en la estructura de compras:{1}".Fmt(erol.codigo,w.EstructuraCosto.descripcion ));
                            }
                                _db.OrdenCompraItems.DeleteOnSubmit(erol);
                            _db.SubmitChanges();
                        }

                        if (drw.RowState == DataRowState.Added)
                        {
                            //siempre se verifica del origen;
                            Insumo insumo = _db.Insumos.Single(p => p.idInternal == drw.Field<int>("idInsumo"));
                              int? compSelcProv = drw.Field<int>("idComparativoItemSelecPrv");
                           
                               
                            OrdenCompraItem ordenCompraItem = new OrdenCompraItem();
                            ordenCompraItem.Add(_db,
                                    (compSelcProv == 0 ? null : compSelcProv),
                                    ordenCompra.idInternal,
                                    insumo.idInternal,
                                    insumo.codigo,
                                    insumo.descripcion,
                                    insumo.InsumoUnidad.abreviacion,
                                    drw.Field<decimal>("descuento"),
                                    drw.Field<decimal>("cantidad"),
                                    drw.Field<decimal>("precioInclIGV"),
                                    drw.Field<decimal>("precioNoIGV"),
                                    drw.Field<decimal>("IGVItem"),
                                    drw.Field<decimal>("subMontoIGV"),
                                    drw.Field<decimal>("subMonto"));

                        }

                    }
                }
                ordenCompra.VerificaItems(_db);
               
                ordenCompra.updateTotales(_db, true);


                if (idComparativo!= null)
                {
                    Comparativo comparativo =
                     _db.Comparativos.Single(p => p.idInternal == idComparativo);
                    comparativo.updateUsoFromOrdenCompra(_db);
                }
                
                ts.Complete();

                return ordenCompra.idInternal;
            }

        }



        public int AddOrdenAnticipo(int idOrden,
                                    DateTime fecha,
                                    string descripcion,
                                    decimal totalIngresado)
        {
            
            OrdenAnticipo ordenAnticipo = new OrdenAnticipo();
            
            int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
           
            using (TransactionScope ts = new TransactionScope())
            {
                dbGestionDataContext _db = new dbGestionDataContext(Parametros.strConnString);
                OrdenCompra orden = _db.OrdenCompras.Single(p => p.idInternal == idOrden);
            
                var totalAnticipo = orden.OrdenAnticipos.Sum(p => p.totalAnticipo);

                if (totalAnticipo.IsNull())
                        totalAnticipo = 0;

                decimal totalComparar = orden.GetTotalComparar();
                decimal totalDisponible = totalComparar - totalAnticipo;


                if (Math.Round(totalDisponible, 4) - Math.Round(totalIngresado,4) < 0)
                   {
                        throw new Exception("Verifique total del Anticipo, solo disponible: {0}{1:N}".Fmt(orden.Moneda1.simbol,totalDisponible));
                   }

                  decimal porcentaje = totalIngresado * 100 / totalComparar;

                  decimal subtotal = 0;
                  decimal IGVTotal = 0;
                  decimal total = 0;

                //sacamos segun sea el caso con o sin IGV
                  if (!orden.Obra.incluyeIGV.Value)
                  {
                      subtotal = totalIngresado;
                      total = (subtotal * (1 + orden.igv.Value));
                      IGVTotal = (total - subtotal);
                  }
                  else
                  {
                      total= totalIngresado;
                      subtotal = (total / (1 + orden.igv.Value));
                      IGVTotal = (total - subtotal);
                  }



                    ordenAnticipo.SetAdd(_db,
                                          fecha,
                                          descripcion,
                                          totalIngresado, 
                                          porcentaje,
                                          idOrden,
                                          IGVTotal,
                                          subtotal,
                                          total,
                                          idEmpleadoEmisor);

                    _db.SubmitChanges();
                 ts.Complete();

                return ordenAnticipo.idInternal;
           }
           
        }

        public void DeleteOrdenAnticipo(int idOrdenAnticipo)
        {
            //no debe estar facturado
            using (TransactionScope ts = new TransactionScope())
            {

                dbGestionDataContext _db = new dbGestionDataContext(Parametros.strConnString);

                var qq = from a in _db.RecepcionDocs
                         where a.idOrdenAnticipo == idOrdenAnticipo
                         select a;

                if (qq.Count() > 0)
                {
                    throw new Exception("No puede ser Anular si Existe FR");
                }

                OrdenAnticipo ordenAnticiopo = _db.OrdenAnticipos.Single(p => p.idInternal == idOrdenAnticipo);

                _db.OrdenAnticipos.DeleteOnSubmit(ordenAnticiopo);
                _db.SubmitChanges();
                ts.Complete();
            }

        }

             // es el unico que puede soportar sin comparativo
        public int addGasto(dbGestionDataContext _db,
                        int idTipoGasto,
                        int? idComparativo,
                        int? idRendicion,
                       int? idComparativoProveedor,
                       DateTime fechaEmision,
                       DateTime FechaEntrega,
                       int idProveedor,
                       int idFormaPago,
                    
                       int idMoneda,
                        string monedaStr,
                       int idEstructuraCompras,
                       bool bitInclIGV,
                       decimal igv,
                       string observaciones,
                       int idObra,
                        bool bitCalcularConIGV,
            string observacionInter,
                       DataSet entityList
            )
        {

            //pudes liquidar el comparativo con otro tipO DE MONEDA
            //puedo cambiar la forma de  pago
            // compartamiento de la Nota de Credito
            // si el insumo que ingresa por orden de gasto puede o no puede cotrolar kardex, o somplemente no se controla.


            
            using (TransactionScope ts = new TransactionScope())
            {
                //DataSet dsDiferencias = new DataSet();
                
               
                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                //--------------------
                bool acceso = new FormularioAcceso().VerificarAcceso(_db,
                    idEmpleadoEmisor,
                    4, //gasto obra
                    idObra,
                    2); //creacion
                //-------------------------     


                

                Empleado emp = _db.Empleados.Single(p => p.idInternal == idEmpleadoEmisor);
                Obra obra = _db.Obras.Single(p => p.idInternal == idObra);
                
                
                // obtenemos el Amacen a donde se genera su ingreso
                int idAlmacen = 0;
                var q = _db.Almacens.Where(p => p.idObra == idObra);
                if (q.Count() > 0) { idAlmacen = q.First().idInternal; }
                else { throw new Exception("No existe Almacen Para la Obra"); }

                //verificamos el tipo de cambio del dia antes de generacion del OC
                // necesario para asegurar la recepcion
                
                Moneda monedaAct = _db.Monedas.Single(p => p.idInternal == 4);
                decimal tp = monedaAct.getTipoCambio(_db, fechaEmision);

                DAL.OrdenCompra db = new DAL.OrdenCompra();

                Proveedor proveedor = _db.Proveedors.Single(p => p.idInternal == idProveedor);
                if (observaciones==String.Empty)
                {
                    throw new Exception("Ingrese Observacion");
                }

                // valida que el total debe ser igual al de la rendicion

                

            // ingresamos la orden de Gasto
                db.Add(_db,
                    idTipoGasto,
                    idRendicion,
                    db.getCorrelativoGasto(_db, idObra),
                    idComparativoProveedor,
                    idAlmacen,
                    proveedor.descripcion,
                    idProveedor,
                    proveedor.contacto,
                    proveedor.ruc,
                    emp.descripcion,
                    emp.idInternal,
                    fechaEmision,
                    fechaEmision,
                    FechaEntrega,
                    idFormaPago,
                    idMoneda,
                    monedaStr,
                    igv,
                    idComparativo,
                     idMoneda == 3 ? 1 : tp,
                    observaciones,
                    idObra,
                    idEmpleadoEmisor,
                    obra.centroCosto,
                    idEstructuraCompras,
                    "",
                    "",
                    "",
                    bitInclIGV,
                    11,
                    false,
                    observacionInter);


                ///-------si existe el comparativo  ya esta aprobado--------//
                ///
                if (idComparativo != null)
                {

                    Comparativo comparativo =
                    _db.Comparativos.Single(p => p.idInternal == idComparativo);

                    ComparativoProveedor cp =
                        _db.ComparativoProveedors.Single(p => p.idinternal == idComparativoProveedor);

                    Empleado empleado = _db.Empleados.Single(p => p.idInternal == comparativo.idEmpleadoAprob);

                    db.updateAutorizacion(_db, 
                                    empleado.idInternal, 
                                    empleado.descripcion,
                                    empleado.firma,
                                    empleado.firma,
                                    empleado.idInternal);
                }
                int contador = 0;
                int clase = 0;
                Insumo objClase = new Insumo();

                DataSet dsDiferencias = new DataSet();




                if (entityList.Tables["OrdenCompraItemInfo"].Rows.Count == 0)
                {
                    throw new Exception("No debe existir Gastos de obra sin Items");
                }

                if (entityList.HasChanges())
                {
                    dsDiferencias.Merge(entityList.GetChanges());


                    foreach (DataRow drw in dsDiferencias.Tables["OrdenCompraItemInfo"].Rows)
                    {
                        if (drw.RowState == DataRowState.Added)
                        {
                            //if (drw.idInternal == 0)
                            //{
                            //    continue;
                            //}
                            Insumo insumo = _db.Insumos.Single(p => p.idInternal == drw.Field<int>("idInsumo"));

                            if (insumo.idPadre == 5571)
                            {
                                throw new Exception("el Insumo :" + insumo.descripcion + " debe ser clasificado ");
                            }
                            contador++;

                            OrdenCompraItem ordenCompraItem = new OrdenCompraItem();
                            var re = from a in _db.Insumos
                                     where a.idInternal == insumo.idInternal
                                     select a.Insumo1.Insumo1.Insumo1;

                            if (contador == 1)
                            {

                                objClase = re.First();
                                clase = objClase.idInternal;
                            }
                            else
                            {
                                if (clase != re.First().idInternal)
                                {
                                    throw new Exception("La Estructura del Insumo:" + insumo.descripcion + "  no pertenece a la clase " + objClase.descripcion + "Genere en otra Orden Gasto");
                                }
                            }
                            int? compSelcProv = drw.Field<int>("idComparativoItemSelecPrv");

                            ordenCompraItem.Add(_db,
                                (compSelcProv == 0 ? null : compSelcProv),
                            db.idInternal,            //OC
                            insumo.idInternal,
                            insumo.codigo,
                            insumo.descripcion,
                            insumo.InsumoUnidad.abreviacion,
                            drw.Field<decimal>("descuento"),
                            drw.Field<decimal>("cantidad"),
                            drw.Field<decimal>("precioInclIGV"),
                            drw.Field<decimal>("precioNoIGV"),
                            drw.Field<decimal>("IGVItem"),
                            drw.Field<decimal>("subMontoIGV"),
                            drw.Field<decimal>("subMonto"));

                        }
                    }
                }

                db.updateTotales(_db,bitCalcularConIGV);
                
                if (idTipoGasto == 5)
                {
                    //caso de CAJA CHICA
                    if (idRendicion == null)
                    {
                        throw new Exception("Debe seleccionar Caja Chica");
                    }else

                    {
                        var rend = _db.Rendicions.Single(p => p.idInternal == idRendicion);

                        if (db.idMoneda != rend.Caja.idMoneda)
                                {
                                    throw new Exception("verifique moneda del comparativo, Caja Chica es en {0}".Fmt(rend.Caja.Moneda.descripcion));
                                }
                                
                                if (rend.idEstado != 41)
                                {
                                    throw new Exception("verifique Estado de la Rendicion Caja Chica");
                                }
                                decimal totalRendicion = rend.toalIngreso;

                                if (Math.Round(db.total.Value) != Math.Round(totalRendicion))
                                {
                                    throw new Exception("El Monto debe ser Igual que en caja");
                                }

                                rend.idEstado=42;
                                _db.SubmitChanges();

                     }
                }



                if (idComparativo != null)
                {
                    Comparativo comparativo =
                     _db.Comparativos.Single(p => p.idInternal == idComparativo);
                    comparativo.updateUsoFromOrdenCompra(_db);
                }

                //asignacion del CAJA CHICA

                

                ts.Complete();

                return db.idInternal;
            }

        }

        public bool deleteOrdenCompra(int idOrdenCompra)
        {
            using (TransactionScope ts = new TransactionScope())
            {

                dbGestionDataContext _db = new dbGestionDataContext(Parametros.strConnString);
                DAL.OrdenCompra oc = _db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);

                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());

                //--------------------
                bool acceso = new FormularioAcceso().VerificarAcceso(_db,
                    idEmpleadoEmisor,
                    3,
                    oc.idObra.Value,
                    4); //total
                //-------------------------     


                Obra obra = _db.Obras.Single(p => p.idInternal == oc.idObra.Value);
                var iwe = from a in _db.OrdenCompraItems
                          where a.idOrdenCompra==idOrdenCompra
                          select a.idInternal;

                var qw = from a in _db.NotaIngresoItems
                        where iwe.Contains(a.idRefItem.Value)
                        & a.idOrigen == 1
                        select a;

                var qq = from a in _db.RecepcionDocs
                         where a.idOrden == idOrdenCompra
                         select a;

                if (qw.Count() > 0)
                {
                    throw new Exception("No puede ser Anular si Existe Notas de Ingreso");
                }

                if (qq.Count() > 0)
                {
                    throw new Exception("No puede ser Anular si Existe FR");
                }
               

                var w = from v in _db.OrdenCompraItems
                        where v.idOrdenCompra == idOrdenCompra
                        where v.cantidadRecep > 0
                        select v;

                if (w.Count() > 0)
                {
                    throw new Exception("Existen Notas de ingreso Registradas");
                }

                if (oc.OrdenAnticipos.Count > 0)
                {
                    throw new Exception("Existen Adelantos de la Orden de Compra");
                }

               
                //no puedes eliminar si existe notas de ingreso
                //para el caso de existir el comparativo,
                if (oc.idComparativo != null)
                {
                        Comparativo comparativo = _db.Comparativos.Single(p => p.idInternal == oc.idComparativo);
                        //3 aprobacion 3
                        if (comparativo.idProveedorSelec != oc.idProveedor)
                        {
                            throw new Exception("No puede eliminar, si el Proveedor  no se encuentra activo en el comparativo");
                        }

                        //no puedes eliminar la orden de compra  si el comparativo esta finalizado
                        if (comparativo.idEstado == 14)
                        {
                            throw new Exception("No puedes Finalizar si el comparativo esta finalizado");
                        }

                        var finalizados = from a in _db.OrdenCompraItems
                                            where
                                                a.idOrdenCompra==idOrdenCompra &
                                                a.ComparativoItemSelecPrv.ComparativoItem.bitFinalizado== true
                                            select a;
                        if (finalizados.Count() > 0)
                        {
                            throw new Exception("Existen Recursos que fueron finalizados");
                        }
                }

                //verificamos que no exista en la structura de compras como referencia

                var wq = from a in _db.EstructuraCostoItems
                        where oc.OrdenCompraItems.Select(p => p.idInternal).Contains(a.idOrdenCompraItemRef.Value)
                        select a;

                foreach (var item in wq)
                {
                    item.SetOrdenCompraRef(null);
                  
                }
                _db.SubmitChanges();
                //---------------------------------------
               _db.OrdenCompraItems.DeleteAllOnSubmit(oc.OrdenCompraItems);
                _db.SubmitChanges();

                var idComparativo = oc.idComparativo;
                // anulamos el documento
                _db.MensajeEmails.DeleteAllOnSubmit(oc.MensajeEmails);
                _db.OrdenCompras.DeleteOnSubmit(oc);
                _db.SubmitChanges();
                //

                if (idComparativo != null)
                {
                    Comparativo comparativo = _db.Comparativos.Single(p => p.idInternal == idComparativo);
                    //actulizo totales del comparativo asociado
                    comparativo.updateUsoFromOrdenCompra(_db);
                }

                


                ts.Complete();
                return true;
            }



        }
        public bool deleteGastoObra(dbGestionDataContext _db,int idGastoObra)
        {
            using (TransactionScope ts = new TransactionScope())
            {

                DAL.OrdenCompra oc = _db.OrdenCompras.Single(p => p.idInternal == idGastoObra);


                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());

                //--------------------
                bool acceso = new FormularioAcceso().VerificarAcceso(_db,
                    idEmpleadoEmisor,
                    4,
                    oc.idObra.Value,
                    4); //total
                //-------------------------     


                Obra obra = _db.Obras.Single(p => p.idInternal == oc.idObra.Value);
                
                
              

                var iwe = from a in _db.OrdenCompraItems
                          where a.idOrdenCompra == idGastoObra
                          select a.idInternal;

                var qw = from a in _db.NotaIngresoItems
                        where iwe.Contains(a.idRefItem.Value) &
                         a.idOrigen == 2
                         select a;

                var qq = from a in _db.RecepcionDocs
                         where a.idOrden == idGastoObra
                         select a;

                if (qw.Count() > 0)
                {
                    throw new Exception("No puede ser Anular si Existe Notas de Ingreso");
                }

                if (qq.Count() > 0)
                {
                    throw new Exception("No puede ser Anular si Existe FR");
                }

                int? idComparativo = oc.idComparativo;
                if (idComparativo != null)
                {
                    Comparativo comparativo = _db.Comparativos.Single(p => p.idInternal == oc.idComparativo);
                    var qcomparativoProveedor = from a in _db.ComparativoProveedors
                                                where a.bitSeleccion == true
                                                & a.idComparativo == oc.idComparativo
                                                & a.idinternal == oc.idProveedorSelec
                                                select a;

                    //3 aprobacion 3
                    if (qcomparativoProveedor.Count() == 0)
                    {
                        throw new Exception("No puede eliminar, si el Proveedor  no se encuentra activo en el comparativo");
                    }
                }
                var q = from a in _db.OrdenCompraItems
                        where a.idOrdenCompra == idGastoObra
                        select a;
                //no puedes eliminar si existe notas de ingreso

                _db.OrdenCompraItems.DeleteAllOnSubmit(q);
                _db.SubmitChanges();


                // anulamos el documento

                _db.OrdenCompras.DeleteOnSubmit(oc);
                _db.SubmitChanges();


                //actulizo totales del comparativo asociado
                if (idComparativo != null)
                {
                    Comparativo comparativo = _db.Comparativos.Single(p => p.idInternal == idComparativo);
                    comparativo.updateUsoFromOrdenCompra(_db);
                }
                _db.SubmitChanges();
                //actualizamos la rendicio en caso de ser caja chica

                if (oc.idTipoOrden == 5)
                {
                    int idRendicion = oc.idRendicion.Value;
                    Rendicion rendicion = _db.Rendicions.Single(p => p.idInternal == idRendicion);
                    rendicion.idEstado = 41;
                    _db.SubmitChanges();
                }
               
                ts.Complete();
                return true;
            }



        }

        public bool anular(int idOrdenCompra, int usuarioAnula, string MotivoAnula)
        {
            //anula la 
            using (TransactionScope ts = new TransactionScope())
            {
                dbGestionDataContext _db = new dbGestionDataContext(Parametros.strConnString);
                OrdenCompra oc = _db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);
                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                //--------------------
                bool acceso = new FormularioAcceso().VerificarAcceso(_db,
                    idEmpleadoEmisor,
                    3, //OrdenCompra
                    oc.idObra.Value,
                    3); //total
                //---

                Comparativo comparativo = _db.Comparativos.Single(p => p.idInternal == oc.idComparativo);
                // no puede anular si existe Notas de ingreso 
                var qw = from a in _db.NotaIngresoItems
                        where a.idRefItem == idOrdenCompra &
                        a.idOrigen == 1
                        select a;

                var qq = from a in _db.RecepcionDocs
                         where a.idOrden == idOrdenCompra
                         select a;

                if (qw.Count() > 0)
                {
                    throw new Exception("No puede ser Anular si Existe Notas de Ingreso");
                }

                if (qq.Count() > 0)
                {
                    throw new Exception("No puede ser Anular si Existe FR");
                }

                // no puede anular si existe FR

                if (oc.idEstado == 12) //solo los emitidos
                {
                    throw new Exception("No puede anular, Verificar  orden de Compra  anulada ");
                }
               

                if (comparativo.idProveedorSelec != oc.idProveedor)
                {
                    throw new Exception("No puede anular, si el Proveedor  no se encuentra activo en el comparativo");
                }

                // por cada ordende compra sus item

                var q = from a in _db.OrdenCompraItems
                        where a.idOrdenCompra == oc.idInternal
                        select a;
                foreach (var i in q)
                {
                    i.bitActivo = false;
                    _db.SubmitChanges();
                }

                // anulamos el documento
                oc.idEstado = 12; // Anulado
                oc.idUsuarioAnula = usuarioAnula;
                oc.fechaAnula = DateTime.Now;
                oc.bitActivo = false;
                _db.SubmitChanges();

                comparativo.updateUsoFromOrdenCompra(_db);
                //--------------------eliminnamos rastros en la estructura de compras----------
                var wq = from a in _db.EstructuraCostoItems
                         where oc.OrdenCompraItems.Select(p => p.idInternal).Contains(a.idOrdenCompraItemRef.Value)
                         select a;

                foreach (var item in wq)
                {
                    item.SetOrdenCompraRef(null);

                }
                _db.SubmitChanges();
               
                //------------------  ------------

                ts.Complete();
            }
            return true;
        }

        //public bool updateAutorizacion(int idOrdenCompra)
        //{
        //    using (TransactionScope ts = new TransactionScope())
        //    {
        //        int idEmpleado = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                
        //        using (dbGestionDataContext _db = new dbGestionDataContext(Parametros.strConnString))
        //        {
        //            Empleado empleado = _db.Empleados.Single(p => p.idInternal == idEmpleado);
                    
        //            OrdenCompra oc = _db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);

        //            // para el caso de existir comparativo
                    
        //            int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
        //            var w = from a in _db.EmpleadoObra
        //                    where a.idObra == oc.idObra.Value & a.idEmpleado == idEmpleado
        //                    select a.Rol;
        //            if (w.Count() == 0)
        //            {
        //                throw new Exception("No tiene acceso a la Obra");
        //            }

        //            Rol rol = w.First();

        //            DAL.Empresa empresa = _db.Empresas.Single(p => p.idInternal == oc.Obra.Proyecto.idEmpresa);


        //            if (oc.idEstado != 11)
        //            {

        //                throw new Exception("El Documento se encuentra Aprobado o Anulado , verifique. ");
        //            }

        //            if (!rol.bitAprobarOrdenCompra)
        //            {
        //                throw new Exception("El usuario no  esta habilitado para realizar la operacion");
        //            }


                    

        //            if (empresa.Logo == null)
        //            {
        //                throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
        //            }
                    
        //            if (empresa.Logo.Trim() == String.Empty)
        //            {
        //                throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
        //            }

                    
        //            if (empleado.firma== null )
        //            {
        //                throw new Exception(String.Format("El usuario {0} no se tiene firma de autorizacion", empleado.descripcion));
        //            }

        //            if (empleado.firma.Trim() == String.Empty)
        //            {
        //                throw new Exception(String.Format("El usuario {0} no se tiene firma de autorizacion", empleado.descripcion));
        //            }
        //            Comparativo comparativo = _db.Comparativos.SingleOrDefault(p => p.idInternal == oc.idComparativo);
        //            if (comparativo != null)
        //            {
        //                Empleado empComparativo = _db.Empleados.SingleOrDefault(p => p.idInternal == oc.Comparativo.idEmpleadoAprob);

        //                if (empComparativo == null)
        //                {
        //                    throw new Exception("El Comparativo  no se Encuentra Aprobado,verifique");
        //                }
        //                oc.updateAutorizacion(_db, 
        //                                    idEmpleado, 
        //                                    empleado.descripcion, 
        //                                    empleado.firma, 
        //                                    empComparativo.firma, 
        //                                    empComparativo.idInternal);

        //            }
        //            else
        //            {
        //                 // debe tener nivel de aprobacion  3 ==comparativos
        //                var compativoBol = new ComparativoBL();
        //                  //-------------------luego tiene que ser porgramado
        //                                decimal totalcomparar=oc.total.Value;
        //                            //si el monto es en dolares lo convertimos en soles
        //                                if (oc.idMoneda == 4)
        //                                    totalcomparar = totalcomparar * oc.tipoCambio.Value;

        //                        if (empleado.idInternal == 118  //ok
        //                            | empleado.idInternal == 121 
        //                            | empleado.idInternal==60    //ok
        //                            | empleado.idInternal == 155 //ok
        //                            | empleado.idInternal==176    //ok
        //                            | empleado.idInternal == 61  //ok
        //                            | empleado.idInternal==45     //ok
        //                            |empleado.idInternal==1  //OK
        //                            | empleado.idInternal==68)    //ok
        //                        {
        //                            if (empleado.idInternal == 68)
        //                            {
        //                                if (totalcomparar > 50000)  //dolares
        //                                {
        //                                    throw new Exception("Monto a Contratar es mayor al permitido: $ 50,000 ");
        //                                }
        //                            }

        //                            if (empleado.idInternal == 155 | empleado.idInternal == 176)
        //                            {
        //                                if (totalcomparar > 25000)
        //                                {
        //                                    throw new Exception("Monto a Contratar es mayor al permitido: S/. 25,000 ");
        //                                }
        //                            }
                                    
                                    
        //                            if (empleado.idInternal == 118 | empleado.idInternal == 61)
        //                            {
        //                                if (totalcomparar > 10000)
        //                                {
        //                                    throw new Exception("Monto a Contratar es mayor al permitido: S/. 10,000 ");
        //                                }
        //                            }

        //                            if (empleado.idInternal == 45 | empleado.idInternal == 60 | empleado.idInternal == 121)
        //                            {
        //                                if (totalcomparar > 5000)
        //                                {
        //                                    throw new Exception("Monto a Contratar es mayor al permitido: S/. 5,000 ");
        //                                }
        //                            }
                                        
                                    
        //                        }
        //                        else
        //                        {
        //                            //if (oc.idTipoOrden == 1)//caso de gasto de obra
        //                            //{
        //                                compativoBol.validaAprobacion3(rol, 0, totalcomparar);
        //                            //}
        //                        }
        //                  //---------------------------------------
        //                //compativoBol.validaAprobacion3(rol, 0, oc.total.Value);
        //                oc.updateAutorizacion(_db, 
        //                                    idEmpleado, 
        //                                    empleado.descripcion, 
        //                                    empleado.firma,
        //                                    empleado.firma,
        //                                    idEmpleado);
        //            }
                   

                
        //        }
        //        ts.Complete();
        //        return true;
        //    }



                   
        //}

        public bool updateAutorizacion(dbGestionDataContext _db,int idOrdenCompra)
        {
            using (TransactionScope ts = new TransactionScope())
            {
                int idEmpleado = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());

                
                    Empleado empleado = _db.Empleados.Single(p => p.idInternal == idEmpleado);

                    OrdenCompra oc = _db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);
                decimal tipoCambioDol=_db.Monedas.Single(p=>p.idInternal==4).getTipoCambio(_db,oc.fechaEmision.Value);

                    // para el caso de existir comparativo

                    int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                    var w = from a in _db.EmpleadoObras
                            where a.idObra == oc.idObra.Value & a.idEmpleado == idEmpleado
                            select a.Rol;
                    if (w.Count() == 0)
                    {
                        throw new Exception("No tiene acceso a la Obra");
                    }

                    Rol rol = w.First();

                    DAL.Empresa empresa = _db.Empresas.Single(p => p.idInternal == oc.Obra.Proyecto.idEmpresa);


                    if (oc.idEstado != 11)
                    {

                        throw new Exception("El Documento se encuentra Aprobado o Anulado , verifique. ");
                    }

                    if (!rol.bitAprobarOrdenCompra)
                    {
                        throw new Exception("El usuario no  esta habilitado para realizar la operacion");
                    }




                    if (empresa.Logo == null)
                    {
                        throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
                    }

                    if (empresa.Logo.Trim() == String.Empty)
                    {
                        throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
                    }


                    if (empleado.firma == null)
                    {
                        throw new Exception(String.Format("El usuario {0} no se tiene firma de autorizacion", empleado.descripcion));
                    }

                    if (empleado.firma.Trim() == String.Empty)
                    {
                        throw new Exception(String.Format("El usuario {0} no se tiene firma de autorizacion", empleado.descripcion));
                    }
                    Comparativo comparativo = _db.Comparativos.SingleOrDefault(p => p.idInternal == oc.idComparativo);
                    if (comparativo != null)
                    {
                        Empleado empComparativo = _db.Empleados.SingleOrDefault(p => p.idInternal == oc.Comparativo.idEmpleadoAprob);

                        if (empComparativo == null)
                        {
                            throw new Exception("El Comparativo  no se Encuentra Aprobado,verifique");
                        }
                        oc.updateAutorizacion(_db,
                                            idEmpleado,
                                            empleado.descripcion,
                                            empleado.firma,
                                            empComparativo.firma,
                                            empComparativo.idInternal);

                    }
                    else
                    {
                        // debe tener nivel de aprobacion  3 ==comparativos
                        var compativoBol = new ComparativoBL();
                        //-------------------luego tiene que ser porgramado
                        decimal totalcomparar = oc.total.Value;
                        //si el monto es en dolares lo convertimos en soles
                        

                        if (empleado.idMoneda == oc.idMoneda)
                        {
                            if (empleado.montoAprobraOC < totalcomparar)
                            {
                                throw new Exception("Monto a Contratar es mayor al permitido: {0} {1:N}".Fmt(empleado.Moneda.simbol, empleado.montoAprobraOC));
                            }
                        }
                        else 
                        {
                            // dolo en soles

                            if (empleado.idMoneda == 4)
                            {
                                //convertimos los valores  segun la moneda

                               // decimal tipoCambio = empleado.Moneda.getTipoCambio(_db, oc.fechaEmision.Value);
                                if (empleado.montoAprobraOC * tipoCambioDol < totalcomparar)
                                {
                                    throw new Exception("Monto a Contratar es mayor al permitido: {0} {1:N}".Fmt(empleado.Moneda.simbol, empleado.montoAprobraOC * oc.tipoCambio.Value));
                                }
                            }else
                            {   //soles
                                if  (empleado.montoAprobraOC < totalcomparar* oc.tipoCambio.Value)
                                {
                                    throw new Exception("Monto a Contratar es mayor al permitido: {0} {1:N}".Fmt(empleado.Moneda.simbol, empleado.montoAprobraOC));
                                }

                            }

                        }

                        //else
                        //{
                        //    compativoBol.validaAprobacion3(rol, 0, totalcomparar);
                        //}
                        //---------------------------------------
                        //compativoBol.validaAprobacion3(rol, 0, oc.total.Value);
                        oc.updateAutorizacion(_db,
                                            idEmpleado,
                                            empleado.descripcion,
                                            empleado.firma,
                                            empleado.firma,
                                            idEmpleado);
                    }



               
                ts.Complete();
                return true;
            }




        }
     

        //public void UpdateOrdenCompraItemTotal(int idOrdenCompraItem,
        //                           decimal subMonto,
        //                           decimal subMontoIGV)
        //{

        //    using (TransactionScope ts = new TransactionScope())
        //    {
        //        int idEmpleado = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());

        //        using (dbGestionDataContext _db = new dbGestionDataContext(Parametros.strConnString))
        //        {
        //            var drw = DbUtil.Db.OrdenCompraItems.Single(a => a.idInternal == idOrdenCompraItem);

        //            if (drw.OrdenCompra.Obra.incluyeIGV.Value)
        //            {
        //                drw.SetUpdateTotalSIIGV(_db, subMontoIGV);
        //            }
        //            else
        //            {
        //                drw.SetUpdateTotalNOIGV(_db, subMonto);
        //            }
        //            _db.SubmitChanges();

        //        }
        //        ts.Complete();
        //    }
        //}


        public bool addMensaje(int idOrden, string desde,string destinatario, 
                          string cc,
                          string asunto,
                          string mensaje,
                          string files)
        {

           

            MensajeEmail mo = new MensajeEmail();
           
                        mo.desde=desde;
                        mo.destinatario=destinatario;
                        mo.cc=cc;
                        mo.Asunto=asunto;
                        mo.mensaje=mensaje;
                        mo.fechaCre=DateTime.Now;
                        mo.archivo = files;
                        mo.idOrden = idOrden;

            DbUtil.Db.MensajeEmails.InsertOnSubmit(mo);

            DbUtil.Db.SubmitChanges();
            return true;
        }


        //public bool updateDesAutorizacion(int idOrdenCompra)
        //{
        //    using (TransactionScope ts = new TransactionScope())
        //    {
        //        int idEmpleado = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
        //        int idRol = int.Parse(System.Web.HttpContext.Current.Session["idrol"].ToString());

        //        using (dbGestionDataContext _db = new dbGestionDataContext(Parametros.strConnString))
        //        {
        //            Empleado empleado = _db.Empleados.Single(p => p.idInternal == idEmpleado);
        //            Rol rol = _db.Rols.Single(p => p.idInternal == idRol);
        //            OrdenCompra oc = _db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);
        //            Empresa empresa = _db.Empresa.Single(p => p.idInternal == oc.Obra.Proyecto.idEmpresa);

        //            if (oc.idEstado != 11)
        //            {

        //                throw new Exception("El Documento se encuentra Aprobado o Anulado , verifique. ");
        //            }

        //            if (!rol.bitAprobarOrdenCompra)
        //            {
        //                throw new Exception("El usuario no se esta habilitado para realizar la operacion");
        //            }




        //            if (empresa.Logo == null)
        //            {
        //                throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
        //            }

        //            if (empresa.Logo.Trim() == String.Empty)
        //            {
        //                throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
        //            }


        //            if (empleado.firma == null)
        //            {
        //                throw new Exception(String.Format("El usuario {0} no se tiene firma de autorizacion", empleado.descripcion));
        //            }

        //            if (empleado.firma.Trim() == String.Empty)
        //            {
        //                throw new Exception(String.Format("El usuario {0} no se tiene firma de autorizacion", empleado.descripcion));
        //            }

        //            oc.updateAutorizacion(_db, idEmpleado, empleado.descripcion, empleado.firma);


        //        }
        //        ts.Complete();
        //        return true;
        //    }




        //}
#endregion



        public int AddGastoFromRendicionCajaChica(dbGestionDataContext _db,Rendicion rendicion)
        {

            // misma empresa  --> de la obra
            var empresa= _db.Proveedors.SingleOrDefault(p=>p.ruc.Trim()==rendicion.Obra.Proyecto.Empresa.ruc.Trim());
            if (empresa == null)
            {
                throw new Exception("La Empresa {0} no existe en Registro de Proveedor".Fmt(rendicion.Obra.Proyecto.Empresa.descripcion));
            }
            var estructuracompras = _db.EstructuraCostos.SingleOrDefault(p => p.idObra == rendicion.idObra & p.bitCaja != null & p.bitCaja==true);
            int idEstructuraCompras = 0;
            if (estructuracompras == null)
            {
                //creo la estructura
                EstructuraCostoBL ecBol = new EstructuraCostoBL();
                idEstructuraCompras = ecBol.add(_db,"CAJA CHICA Y RENDICIONES", rendicion.idObra, 4,true);

            }
            else { idEstructuraCompras = estructuracompras.idInternal; }

            // para el item que debe bajar de la EC el insumo es  ID=6897

            ///si es con o sin  IGV

            decimal totalItem = rendicion.RendicionItems.Sum(u => u.total);
            decimal precioIGV = totalItem;
            decimal precioSINIGV = totalItem;
            bool InclIGV = _db.Obras.Single(p => p.idInternal == rendicion.idObra).incluyeIGV.Value;
            
            decimal IGVValor = new Impuesto().GetIGV(_db, 
                                                rendicion.fechaAprobacion.Value);
            
            decimal cantidad = 1;
            bool CalcularIGV = false; //caja chica no calcula el IGV
            var ordenCompraItemInfo = this.GetOrdenCompraItemFromValor(_db,
                                                                    6897, 
                                                                    cantidad, 
                                                                    IGVValor, 
                                                                    InclIGV,
                                                                    CalcularIGV,
                                                                    totalItem, 
                                                                    totalItem);


            DataTable dtList = Util.EntidadToDataTable(this.getOrdenCompraItem(_db, 0));
            DataSet lista = new DataSet();

            dtList.TableName = this.ORDENCOMPRAITEMINFO;


            lista.Tables.Add(dtList);
            lista.AcceptChanges();

            lista.Tables[0].ImportRow(Util.EntidadToDataRow(ordenCompraItemInfo));

           int idOrden= this.addGasto(_db,
                            5,//caja chica
                            null,
                            rendicion.idInternal,
                            null,
                            DateTime.Now,
                            DateTime.Now,
                            empresa.idInternal,
                            2, //contado
                            rendicion.Caja.idMoneda,
                            rendicion.Caja.Moneda.descripcion,
                            idEstructuraCompras,
                            InclIGV,
                            IGVValor/100,
                            "CAJA CHICA",
                            rendicion.idObra,
                            false,
                            "CAJA CHICA Custodio:{0}".Fmt(rendicion.Caja.Empleado.descripcion),
                            lista);
           return idOrden; 
        }
#region Extension
       
#endregion

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public OrdenCompraInsertInfo loadOrdenCompraFromComparativo(int idComparativo)
        {

            
                OrdenCompra oc = new OrdenCompra();

                var q=from a in DbUtil.Db.ComparativoProveedors
                        where a.bitSeleccion == true & a.idComparativo == idComparativo
                        select new OrdenCompraInsertInfo
                        {
                            numDocumento = oc.getCorrelativoCompra(DbUtil.Db, a.Comparativo.idObra.Value),
                            idProveedor = a.idProveedor.Value,
                            idComparativoProveedor = a.idinternal,
                            proveedor = a.Proveedor.descripcion,
                            idMoneda = a.idMoneda.Value,
                            moneda = a.Moneda.descripcion,
                            tipoCambio = a.tipoCambio.Value,
                            formaPago = a.FormaPago.descripcion,
                            idObra = a.Comparativo.idObra.Value,
                            idFormaPago = a.idFormaPago.Value,
                            idComparativo = a.idComparativo.Value,
                            desComparativo=a.Comparativo.descripcion,
                            contacProveedor=a.Proveedor.contacto,
                            numComparativo=a.Comparativo.numDocumento,
                            centroCosto	=a.Comparativo.Obra.centroCosto,
                            estructura=a.Comparativo.EstructuraCosto.Estructura.descripcion,
                            idEstructura=a.Comparativo.idEstructuraCosto.Value,
                            autorizado=a.Comparativo.Empleado.descripcion,
                            revisado=a.Comparativo.Empleado1.descripcion,
                            fechaComparativo=a.Comparativo.fecha.Value,
                            saldoComparativo = String.Format("{0} {1:N}",a.Moneda.simbol , (a.totalContratado.Value - a.totalUso.Value)),
                            };
                
                return (q).First();


            

        }



        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public OrdenCompraInsertInfo loadOrdenGastoFromComparativo(int idComparativo)
        {

                OrdenCompra oc = new OrdenCompra();

                var q = from a in DbUtil.Db.ComparativoProveedors
                        where a.bitSeleccion == true & a.idComparativo == idComparativo
                        select new OrdenCompraInsertInfo
                        {
                            numDocumento = oc.getCorrelativoGasto(DbUtil.Db, a.Comparativo.idObra.Value),
                            idProveedor = a.idProveedor.Value,
                            idComparativoProveedor = a.idinternal,
                            proveedor = a.Proveedor.descripcion,
                            idMoneda = a.idMoneda.Value,
                            moneda = a.Moneda.descripcion,
                            tipoCambio = a.tipoCambio.Value,
                            formaPago = a.FormaPago.descripcion,
                            idObra = a.Comparativo.idObra.Value,
                            idFormaPago = a.idFormaPago.Value,
                            idComparativo = a.idComparativo.Value,
                            desComparativo = a.Comparativo.descripcion,
                            contacProveedor = a.Proveedor.contacto,
                            numComparativo = a.Comparativo.numDocumento,
                            centroCosto = a.Comparativo.Obra.centroCosto,
                            estructura = a.Comparativo.EstructuraCosto.Estructura.descripcion,
                            idEstructura = a.Comparativo.EstructuraCosto.idPadre.Value,
                            autorizado = a.Comparativo.Empleado.descripcion,
                            revisado = a.Comparativo.Empleado1.descripcion,
                            fechaComparativo = a.Comparativo.fecha.Value,
                            saldoComparativo = String.Format("{0} {1:N}", a.Moneda.simbol, (a.totalContratado.Value - a.totalUso.Value)),
                        };

                return (q).First();

        }
                                                                  
         
        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public List<OrdenCompraItemInfo> getListFromComparativo(int idComparativo,
            bool InclIGV,
            decimal IGVProc,
            int idComparativoProveeedor,
            int idOrdenCompraQNDBUSAR,
            List<int> idOrdenComprasEliminadoAConsiderar,
            List<int> ComparativoItemProvYaUtilizado)
        {

            // aquellos que faltan despachar
            //IGVProc debe ser 18% 
            
            decimal IGV = 1 + IGVProc / 100;

            var q = from a in DbUtil.Db.ComparativoItemSelecPrv
                    where a.ComparativoItem.idComparativo == idComparativo &
                    a.idComparativoProv == idComparativoProveeedor &
                    
                    !ComparativoItemProvYaUtilizado.Contains(a.idInternal) 
                    select a;



            DataTable dt = new DataTable();

            List<OrdenCompraItemInfo> result = new List<OrdenCompraItemInfo>();


            foreach (ComparativoItemSelecPrv item in q.ToList())
            {
                // verificar si esta  ingresando a la db por
                

                var ew= from a in item.OrdenCompraItems
                        where a.idOrdenCompra==idOrdenCompraQNDBUSAR
                        & a.idComparativoItemSelecPrv==item.idInternal
                        select a;
                
                if (ew.Count()>0)
                {
                    continue;
                }

                if (!(item.total - item.totalUso > 0) )
                {
                    continue;
                }

                OrdenCompraItemInfo ordenItem = new OrdenCompraItemInfo();
                ordenItem.LoadFromComparativoItemSelecPrv(item,InclIGV,IGVProc);

                result.Add(ordenItem);
            }


            //agregamos estos que estan retirados del formulario DELETES en el DATASET
            //tambien si fue agregado de nuevo en el DataSet


            //para aquellos que se elimino y se vuelven a tomar de la lista
            var ultimos= from a in DbUtil.Db.OrdenCompraItems
                         where idOrdenComprasEliminadoAConsiderar.Contains(a.idInternal)
                        & !ComparativoItemProvYaUtilizado.Contains(a.idComparativoItemSelecPrv.Value)
                         select a;

            foreach (var item in ultimos.ToList())
            {
                
                OrdenCompraItemInfo ordenItem = new OrdenCompraItemInfo();
                ordenItem.LoadFromOrdenCompraRetiradosCol(DbUtil.Db,item,InclIGV,IGVProc);

                result.Add(ordenItem);
            }

            return result;


        }

        

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public List<OrdenCompraItemInfo> getOrdenGastoItemListFromComparativo(int idComparativo, bool InclIGVObra,
            decimal IGVProc,
            int idComparativoProveeedor)
        {
            // aquellos que faltan despachar
            //IGVProc debe ser 18% 

            decimal IGV = 1 + IGVProc / 100;

            var q = from a in DbUtil.Db.view_comparativoItemSelecProv
                    where a.idComparativo == idComparativo &
                    a.idComparativoProv == idComparativoProveeedor &
                    (a.total - a.totalUso) > 0
                    select a;

            List<OrdenCompraItemInfo> result = new List<OrdenCompraItemInfo>();


            foreach (view_comparativoItemSelecProv item in q.ToList())
            {
                // verificar si esta  ingresando a la db pro cada interacion

                OrdenCompraItemInfo ordenItem = new OrdenCompraItemInfo();

                int idInsumo = DbUtil.Db.ComparativoItems.Single(p => p.idInternal == item.idComparativoItem).EstructuraCostoItem.idInsumo.Value;
                


                ordenItem.idInternal = Parametros.GenerarID();
                ordenItem.idComparativoItemSelecPrv = item.idInternal;
                ordenItem.idInsumo = idInsumo;
                ordenItem.Descripcion = item.descripcion;
                ordenItem.codigo = item.codigo;
                ordenItem.unidad = item.unidad;
                ordenItem.cantidad = (item.cantidad.Value - item.cantidadUso.Value);
                ordenItem.CantidadDisp = (item.cantidad.Value - item.cantidadUso.Value);


                if (InclIGVObra)
                {
                    ordenItem.subMontoIGV = (item.total.Value - item.totalUso.Value);  //subtotal ya con el IGV
                    ordenItem.subMonto = Math.Round(ordenItem.subMontoIGV / IGV, 4);
                    ordenItem.precioInclIGV = item.precio.Value;
                    ordenItem.precioNoIGV = Math.Round(ordenItem.subMonto / ordenItem.cantidad, 4);
                }
                else
                {
                    ordenItem.subMonto = (item.total.Value - item.totalUso.Value);
                    ordenItem.subMontoIGV = Math.Round(ordenItem.subMonto * IGV, 4);
                    
                    ordenItem.precioInclIGV = Math.Round(ordenItem.subMontoIGV / ordenItem.cantidad, 4);
                    ordenItem.precioNoIGV = item.precio.Value;

                }

                ordenItem.subMontoDisp = ordenItem.subMonto;
                ordenItem.subMontoDispIGV = ordenItem.subMontoIGV;
                ordenItem.IGVItem = ordenItem.subMontoIGV - ordenItem.subMonto;
                ordenItem.descuento = 0;

                result.Add(ordenItem);
            }


            return result;


        }


        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public List<OrdenCompraRPT> loadOrdenCompraRPT(int idOrdenCompra,int? idOrdenAnticipo)
        {
                      // segun sea el caso de incluye o no IGV
                //string IGVval = _db.GrupoDatoitem.Single(p => p.idInternal == 10).descripcion;

                //string IGV = IGVval + "%";
                OrdenCompra oc = DbUtil.Db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);
                DAL.Empresa empresa = DbUtil.Db.Empresas.Single(p => p.idInternal == oc.Obra.Proyecto.idEmpresa);

                if (empresa.Logo == null)
                {
                    throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
                }

                if (empresa.Logo.Trim() == String.Empty)
                {
                    throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
                }
                 
              
                
                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                
            Empleado empleado = DbUtil.Db.Empleados.Single(p => p.idInternal == idEmpleadoEmisor);

            string archivoLogo = DbUtil.Db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra).Obra.Proyecto.Empresa.Logo;
            string ArchivoFirmaAutoizado= oc.firmaAutorizado;
            string ArchivoFirmaComparativo = oc.firmaAprobComparativo;
            string empleadoComparativo = "";
              
                byte[] firma= new byte[200];
                byte[] firmaComparativo = new byte[200];

                if (ArchivoFirmaAutoizado == null)
                {
                    firma = null;
                }
                else
                {
                    string rutaFirma = System.Web.HttpContext.Current.Server.MapPath("../App_Data/Empleado/Firma/" + oc.idAutorizado.ToString() + "/" + ArchivoFirmaAutoizado);
                    firma = UtilityExtensions.Util.FileToBytesImage(rutaFirma);
                }
                if (ArchivoFirmaComparativo == null)
                {
                    firmaComparativo = null;
                    empleadoComparativo = string.Empty;
                }
                else
                {
                    string rutaFirma = System.Web.HttpContext.Current.Server.MapPath("../App_Data/Empleado/Firma/" + oc.idEmpAprobComparativo.ToString() + "/" + ArchivoFirmaComparativo);
                    empleadoComparativo = DbUtil.Db.Empleados.Single(p => p.idInternal == oc.idEmpAprobComparativo).descripcion;
                    firmaComparativo = UtilityExtensions.Util.FileToBytesImage(rutaFirma);
                }

                string rutaLogo =System.Web.HttpContext.Current.Server.MapPath("../App_Data/Empresa/Logo/" + archivoLogo);
                
                byte[] imagen = UtilityExtensions.Util.FileToBytesImage(rutaLogo);

               // string logo = String.Format("{0}/Images/logoCiesa.jpg",AppDomain.CurrentDomain.);
              
                //NO IGV------------------
            // agregado para el caso de anticipo
            
            //primero preraramos lo que necesitamos traer

                //para el mensajea a visualizar 
            var re= from  t in DbUtil.Db.OrdenAnticipos
                    where t.idOrden==idOrdenCompra
                    select t;
            string mensajefinal="";

            if(re.Count()>0)
            {
                mensajefinal = "LISTA OC ANTICIPO:";
                foreach(var item in re)
                {
                    mensajefinal =mensajefinal +" FECHA:{0}  MONTO:{1}{2} / ".Fmt(item.fecha.ToShortDateString(),item.OrdenCompra.Moneda1.simbol, item.total.ToString("N"));
                }
                
            }

                var q = from a in DbUtil.Db.OrdenCompraItems
                        join b in DbUtil.Db.OrdenAnticipos.Where(r=>r.idInternal==idOrdenAnticipo) on a.idOrdenCompra equals b.idOrden into viewObra
                        from c in viewObra.DefaultIfEmpty()
                        where a.idOrdenCompra == idOrdenCompra
                        select new OrdenCompraRPT
                        {
                            idInternal = a.idOrdenCompra.Value,
                            
                            proveedor = a.OrdenCompra.proveedor.ToUpper(),
                            rucProveedor=a.OrdenCompra.Proveedor1.ruc,
                            contacto = a.OrdenCompra.Proveedor1.contacto,
                            telefonoContacto=a.OrdenCompra.Proveedor1.telefonoOficina1,
                            desComparativo = String.Format("{0}-{1}",a.OrdenCompra.Comparativo.numDocumento,a.OrdenCompra.Comparativo.descripcion),
                            
                            fechaPedido = a.OrdenCompra.fechaPedido.Value.ToShortDateString(),
                            fechaContrato = a.OrdenCompra.fechaContrato.Value.ToShortDateString(),
                            actividad = a.OrdenCompra.Obra.TipoObra.descripcion.ToUpper(),
                            formaPago = a.OrdenCompra.FormaPago.descripcion.ToUpper(),
                            emitidoPor = empleado.descripcion.ToUpper(),
                            NumDocumento = a.OrdenCompra.numDocumento,
                            
                            CentroCosto = a.OrdenCompra.centroCosto,
                            Obra = a.OrdenCompra.Obra.descripcion,
                            facturarNombrede = a.OrdenCompra.Obra.Proyecto.Empresa.razonSocial,
                            direccion = a.OrdenCompra.Obra.Proyecto.Empresa.direccion,
                            ruc = a.OrdenCompra.Obra.Proyecto.Empresa.ruc,
                            SimboloMoneda=a.OrdenCompra.Moneda1.simbol,
                            codigo = a.codigo,
                            descripcionRecurso = a.Descripcion,
                            unidad = a.unidad,
                            cantidad = a.cantidad.Value,
                            descuento = a.descuento.Value,
                            LogoEmpresa = imagen,
                            IGV=String.Format("{0:N1} %",a.OrdenCompra.igv.Value*100),
                            precio =(a.OrdenCompra.bitInclIGV==true?a.precioInclIGV.Value:a.precioNoIGV.Value),
                            totalitem = (a.OrdenCompra.bitInclIGV==true?a.subMontoIGV.Value:a.subMonto.Value),
                            
                            
                            
                            //IGV =a.OrdenCompra.

                            
                            revisadoPor = a.OrdenCompra.revisado,
                            autorizadoPor = a.OrdenCompra.autorizado,
                            direccionEntregaMercaderia = a.OrdenCompra.direccionEntrega,
                            AtensionEntregaMercaderia = a.OrdenCompra.atencionEntrega,
                            direccionEntregaComprobantePago = a.OrdenCompra.direccionEntComprobante,
                            FirmaAutorizado = firma,
                            FirmaComparativo = firmaComparativo,
                            EmpAprobadoComparativo=empleadoComparativo,
                            observacion = a.OrdenCompra.observaciones,
                            //para el caso que sea anticipo

                            fechaemision = (idOrdenAnticipo==null)?     a.OrdenCompra.fechaEmision.Value.ToShortDateString():c.fecha.ToShortDateString() ,
                            mensajeFinal = (idOrdenAnticipo == null) ?  mensajefinal : c.descripcion,
                            subTotal =     (idOrdenAnticipo==null)?     a.OrdenCompra.subTotal.Value:c.subTotal,
                            IGVTotal =     (idOrdenAnticipo==null)?     a.OrdenCompra.IGVTotal.Value:c.IGVTotal,
                            total =        (idOrdenAnticipo==null)?     a.OrdenCompra.total.Value:c.total,
                            
                        };
                return q.ToList();
           

        }

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public List<GastoObraRPT> loadGastoObraRPT(int idOrdenCompra)
        {

           
                // segun sea el caso de incluye o no IGV
                //string IGVval = _db.GrupoDatoitem.Single(p => p.idInternal == 10).descripcion;

                //string IGV = IGVval + "%";
                OrdenCompra oc = DbUtil.Db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra);
                DAL.Empresa empresa = DbUtil.Db.Empresas.Single(p => p.idInternal == oc.Obra.Proyecto.idEmpresa);

                if (empresa.Logo == null)
                {
                    throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
                }

                if (empresa.Logo.Trim() == String.Empty)
                {
                    throw new Exception("Verifique logo de la empresa antes de Aprobar la orden de compra");
                }



                int idEmpleadoEmisor = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
                Empleado empleado = DbUtil.Db.Empleados.Single(p => p.idInternal == idEmpleadoEmisor);




                string archivoLogo = DbUtil.Db.OrdenCompras.Single(p => p.idInternal == idOrdenCompra).Obra.Proyecto.Empresa.Logo;
                string rutaLogo = System.Web.HttpContext.Current.Server.MapPath("../App_Data/Empresa/Logo/" + archivoLogo);

                byte[] imagen = UtilityExtensions.Util.FileToBytesImage(rutaLogo);
                
                

                string ArchivoFirmaAutoizado = oc.firmaAutorizado;

                byte[] firma = new byte[200];

                if (ArchivoFirmaAutoizado == null)
                {
                    firma = null;
                }
                else
                {
                    string rutaFirma = System.Web.HttpContext.Current.Server.MapPath("../App_Data/Empleado/Firma/" + oc.idAutorizado.ToString() + "/" + ArchivoFirmaAutoizado);
                    firma = UtilityExtensions.Util.FileToBytesImage(rutaFirma);

                }


                



                // string logo = String.Format("{0}/Images/logoCiesa.jpg",AppDomain.CurrentDomain.);

                //NO IGV------------------

                var q = from a in DbUtil.Db.OrdenCompraItems
                        where a.idOrdenCompra == idOrdenCompra
                        select new GastoObraRPT
                        {
                            idInternal = a.idOrdenCompra.Value,
                            proveedor = a.OrdenCompra.proveedor.ToUpper(),
                            rucProveedor = a.OrdenCompra.docProveedor,
                            contacto = a.OrdenCompra.Proveedor1.contacto.ToUpper(),
                            telefonoContacto = a.OrdenCompra.Proveedor1.telefonoOficina1,
                            fechaemision = a.OrdenCompra.fechaEmision.Value.ToShortDateString(),
                            fechaPedido = a.OrdenCompra.fechaPedido.Value.ToShortDateString(),
                            fechaContrato = a.OrdenCompra.fechaContrato.Value.ToShortDateString(),
                            actividad = a.OrdenCompra.Obra.TipoObra.descripcion.ToUpper(),
                            formaPago = a.OrdenCompra.FormaPago.descripcion.ToUpper(),
                            emitidoPor = empleado.descripcion.ToUpper(),
                            NumDocumento = a.OrdenCompra.numDocumento,
                            
                            CentroCosto = a.OrdenCompra.centroCosto,
                            Obra = a.OrdenCompra.Obra.descripcion,
                            facturarNombrede = a.OrdenCompra.Obra.Proyecto.Empresa.razonSocial,
                            direccion = a.OrdenCompra.Obra.Proyecto.Empresa.direccion,
                            ruc = a.OrdenCompra.Obra.Proyecto.Empresa.ruc,
                            SimboloMoneda = a.OrdenCompra.Moneda1.simbol,
                            codigo = a.codigo,
                            descripcionRecurso = a.Descripcion,
                            unidad = a.unidad,
                            cantidad = a.cantidad.Value,
                            descuento = a.descuento.Value,
                            LogoEmpresa = imagen,
                            IGV = String.Format("{0:N1} %", a.OrdenCompra.igv.Value * 100),
                            precio = (a.OrdenCompra.bitInclIGV == true ? a.precioInclIGV.Value : a.precioNoIGV.Value),
                            totalitem = (a.OrdenCompra.bitInclIGV == true ? a.subMontoIGV.Value : a.subMonto.Value),
                            observacion = a.OrdenCompra.observaciones,
                            subTotal = a.OrdenCompra.subTotal.Value,
                            IGVTotal = a.OrdenCompra.IGVTotal.Value,
                            firma=firma,
                            total = a.OrdenCompra.total.Value,
                            revisadoPor = a.OrdenCompra.revisado,
                            autorizadoPor = a.OrdenCompra.autorizado,
                            
                            desComparativo =a.OrdenCompra.idComparativo==null?"":a.OrdenCompra.Comparativo.descripcion,
                            };
                return q.ToList();
           

        }

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public OrdenCompraInfo loadGastoObra(int idGastoObra)
        {

                

                var q = from a in DbUtil.Db.OrdenCompras
                        where a.idInternal == idGastoObra
                       
                        select new OrdenCompraInfo
                        {
                            idTipoOrden=a.idTipoOrden.Value,
                            tipoOrden=a.TipoOrden.descripcion,
                            idInternal = a.idInternal,
                            proveedor = a.proveedor,
                            atencionEntrega=a.atencionEntrega,
                            autorizado=a.autorizado,
                            bitActivo=a.bitActivo.Value,
                            bitInclIGV=a.bitInclIGV.Value,
                            centroCosto=a.centroCosto,
                            contacProveedor=a.contacProveedor,
                            desComparativo=a.Comparativo.descripcion,
                            direccionEntComprobante=a.direccionEntComprobante,
                            direccionEntrega=a.direccionEntrega,
                            emisor=a.emisor,
                            estado=a.GrupoDatoitem.descripcion,
                            estructuraCosto=a.idEstructuraCompras==null?"":a.EstructuraCosto.descripcion,
                            fechaAnula=a.fechaAnula,
                            fechaContrato=a.fechaContrato.Value,
                            fechaCre=a.fechaCre.Value,
                            fechaEmision=a.fechaEmision.Value,
                            fechaMod=a.fechaMod.Value,
                            fechaPedido=a.fechaPedido,
                            formaPago=a.FormaPago.descripcion,
                            idComparativo=a.idComparativo.Value,
                            idEstado=a.idEstado.Value,
                            idEstructuraCosto=a.idEstructuraCompras,
                            idFormaPago=a.idFormaPago.Value,
                            idMoneda=a.idMoneda.Value,
                            idObra=a.idObra.Value,
                            idProveedor=a.idProveedor.Value,
                            idProveedorSelec=a.idProveedorSelec.Value,
                            idUsuarioAnula=a.idUsuarioAnula,
                            IGV=a.igv.Value,//(a.igv*100).Value.ToString("N"),
                            IGVTotal=a.IGVTotal.Value,
                            moneda=a.moneda,
                            numComparativo=a.Comparativo.numDocumento,
                            numDocumento=a.numDocumento,
                            observaciones=a.observaciones,
                            simbol=a.Moneda1.simbol,
                            subTotal=a.subTotal.Value,
                            tipoCambio=a.tipoCambio.Value,
                            total=a.total.Value,
                            UsuarioCre=a.UsuarioCre.Value,
                            UsuarioMod=a.UsuarioMod.Value,
                            idRendicion=a.idRendicion,
                            };
                return q.First();
           
        }



        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public OrdenCompraInfo loadOrdenCompra(int idOrdenCompra)
        {

           
                var q = from a in DbUtil.Db.OrdenCompras
                        where a.idInternal == idOrdenCompra
                        select new OrdenCompraInfo
                        {
                            idInternal = a.idInternal,
                            proveedor = a.ComparativoProveedor.Proveedor.descripcion.ToUpper(),
                            atencionEntrega = a.atencionEntrega,
                            autorizado = a.autorizado,
                            bitActivo = a.bitActivo.Value,
                            bitInclIGV = a.bitInclIGV.Value,
                            centroCosto = a.centroCosto,
                            contacProveedor = a.contacProveedor,
                            desComparativo = a.Comparativo.descripcion,
                            direccionEntComprobante = a.direccionEntComprobante,
                            direccionEntrega = a.direccionEntrega,
                            emisor = a.emisor,
                            estado = a.GrupoDatoitem.descripcion,
                            estructuraCosto = a.idEstructuraCompras==null?"":a.EstructuraCosto.descripcion,
                            fechaAnula = a.fechaAnula,
                            fechaContrato = a.fechaContrato.Value,
                            fechaCre = a.fechaCre.Value,
                            fechaEmision = a.fechaEmision.Value,
                            fechaMod = a.fechaMod.Value,
                            fechaPedido = a.fechaPedido,
                            formaPago = a.FormaPago.descripcion,
                            idComparativo = a.idComparativo.Value,
                            idEstado = a.idEstado.Value,
                            idEstructuraCosto = a.idEstructuraCompras,
                            idFormaPago = a.idFormaPago.Value,
                            idMoneda = a.idMoneda.Value,
                            idObra = a.idObra.Value,
                            idProveedor = a.idProveedor.Value,
                            idProveedorSelec = a.idProveedorSelec.Value,
                            idUsuarioAnula = a.idUsuarioAnula,
                            IGV = a.igv.Value,//(a.igv*100).Value.ToString("N"),
                            IGVTotal = a.IGVTotal.Value,
                            moneda = a.moneda,
                            numComparativo = a.Comparativo.numDocumento,
                            numDocumento = a.numDocumento,
                            observaciones = a.observaciones,
                            simbol = a.Moneda1.simbol,
                            subTotal = a.subTotal.Value,
                            tipoCambio = a.tipoCambio.Value,
                            total = a.total.Value,
                            UsuarioCre = a.UsuarioCre.Value,
                            UsuarioMod = a.UsuarioMod.Value,
                            bitAnticipo=a.bitAnticipo.Value,
                            emailContacto=a.ComparativoProveedor.Proveedor.emailContacto,

                            
                            
                            
                        };
                return q.First();
           
        }


        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public OrdenInfo loadOrden(int idOrden)
        {


            var q = from a in DbUtil.Db.OrdenCompras
                    where a.idInternal == idOrden & a.bitActivo==true
                    select new OrdenInfo
                    {
                        idInternal = a.idInternal,
                        idTipoOrden=a.idTipoOrden.Value,
                        proveedor = a.proveedor,
                        bitActivo = a.bitActivo.Value,
                       centroCosto = a.centroCosto,
                        desComparativo = a.Comparativo.descripcion,
                        emisor = a.emisor,
                        estado = a.GrupoDatoitem.descripcion,
                        estructuraCosto = a.idEstructuraCompras == null ? "" : a.EstructuraCosto.descripcion,
                        fechaCre = a.fechaCre.Value,
                        fechaEmision = a.fechaEmision.Value,
                        fechaMod = a.fechaMod.Value,
                        formaPago = a.FormaPago.descripcion,
                        idComparativo =a.idComparativo==null?0: a.idComparativo.Value,
                        idEstado = a.idEstado.Value,
                        idEstructuraCosto = a.idEstructuraCompras,
                        idFormaPago = a.idFormaPago.Value,
                        idMoneda = a.idMoneda.Value,
                        idObra = a.idObra.Value,
                        idProveedor = a.idProveedor.Value,
                        idProveedorSelec = a.idProveedorSelec==null?0: a.idProveedorSelec.Value,
                     
                        IGV = a.igv.Value,//(a.igv*100).Value.ToString("N"),
                        IGVTotal = a.IGVTotal.Value,
                        moneda = a.moneda,
                        numComparativo = a.idComparativo==null?"": a.Comparativo.numDocumento,
                        numDocumento = a.numDocumento,
                        observaciones = a.observaciones,
                        simbol = a.Moneda1.simbol,
                        subTotal = a.subTotal.Value,
                        tipoCambio = a.tipoCambio.Value,
                        total = a.total.Value,
                        tipoOrden=a.TipoOrden.descripcion,
                        numDocumentoStr=String.Format("{0} {1}",a.TipoOrden.simbol,a.numDocumento),
                        tipoFormulario=(a.idTipoOrden>1?"GastoObraReadForm.aspx":"OrdenCompraReadForm.aspx"),
                        bitAnticipo=a.bitAnticipo.Value,

                        numRendicion=(a.idRendicion!=null)?a.Rendicion.numDocumento:"",

                    };
            return q.First();

        }


        //public  List<OrdenCompraItem>  LoadFamilia(int idObra)
        //{

        //    var q = from a in DbUtil.Db.OrdenCompraItems
        //            where a.Insumo.Insumo1.Insumo2.nivel == 0
        //            select new
        //            {
        //                idinternal = a.Insumo.Insumo1.Insumo2.idInternal,
        //                descripcion = a.Insumo.Insumo1.Insumo2.descripcion
        //            };



        //}






   

     
        #region "get OC"
 
        public IQueryable<OrdenCompraListInfo> ApplySort(IQueryable<OrdenCompraListInfo> q, string sortExpression)
        {
            switch (sortExpression)
            {
                case "numDocumento":
                    q = q.OrderBy(b => b.numDocumento);
                    break;
                case "numDocumento DESC":
                    q = q.OrderByDescending(b => b.numDocumento);
                    break;
                case "fechaEmision":
                    q = q.OrderBy(p=>p.numDocumento).OrderBy(b => b.fechaEmision);
                    break;
                case "fechaEmision DESC":
                    q = q.OrderByDescending(p=>p.numDocumento).OrderByDescending(b => b.fechaEmision);
                    break;
                case "proveedor":
                    q = q.OrderBy(b => b.proveedor);
                    break;
                case "proveedor DESC":
                    q = q.OrderByDescending(b => b.proveedor);
                    break;

                case "subTotal":
                    q = q.OrderBy(b => b.subTotal);
                    break;
                case "subTotal DESC":
                    q = q.OrderByDescending(b => b.subTotal);
                    break;


                case "IGVTotal":
                    q = q.OrderBy(b => b.IGVTotal);
                    break;
                case "IGVTotal DESC":
                    q = q.OrderByDescending(b => b.IGVTotal);
                    break;

                case "docProveedor":
                    q = q.OrderBy(b => b.docProveedor);
                    break;
                case "docProveedor DESC":
                    q = q.OrderByDescending(b => b.docProveedor);
                    break;

                case "total":
                    q = q.OrderBy(b => b.total);
                    break;
                case "total DESC":
                    q = q.OrderByDescending(b => b.total);
                    break;
                case "condicion":
                    q = q.OrderBy(b => b.condicion);
                    break;
                case "condicion DESC":
                    q = q.OrderByDescending(b => b.condicion);
                    break;
                case "numComparativo":
                    q = q.OrderBy(b => b.numComparativo);
                    break;
                case "numComparativo DESC":
                    q = q.OrderByDescending(b => b.numComparativo);
                    break;
                case "formaPago":
                    q = q.OrderBy(b => b.formaPago);
                    break;
                case "formaPago DESC":
                    q = q.OrderByDescending(b => b.formaPago);
                    break;

                case "obraStr":
                    q = q.OrderBy(b => b.obraStr);
                    break;
                case "obraStr DESC":
                    q = q.OrderByDescending(b => b.obraStr);
                    break;
                default:
                      q = q.OrderByDescending(p=>p.numDocumento).OrderByDescending(b => b.fechaEmision);
                    break;
            }
            return q;
        }

        private IQueryable<OrdenAnticipoInfo> ApplySort(IQueryable<OrdenAnticipoInfo> q, string sortExpression)
        {
            switch (sortExpression)
            {
                case "fecha":
                    q = q.OrderBy(b => b.fecha);
                    break;
                case "fecha DESC":
                    q = q.OrderByDescending(b => b.fecha);
                    break;
                case "descripcion":
                    q = q.OrderByDescending(p=>p.descripcion).OrderBy(b => b.fecha);
                    break;
                case "descripcion DESC":
                    q = q.OrderByDescending(p=>p.descripcion).OrderByDescending(b => b.fecha);
                    break;
               


                case "porcentaje":
                    q = q.OrderBy(b => b.porcentaje);
                    break;
                case "porcentaje DESC":
                    q = q.OrderByDescending(b => b.porcentaje);
                    break;


                case "total":
                    q = q.OrderBy(b => b.total);
                    break;
                case "total DESC":
                    q = q.OrderByDescending(b => b.total);
                    break;


                default:
                    q = q.OrderByDescending(b => b.fecha).OrderByDescending(p => p.descripcion);
                    break;
            }
            return q;
        }

        private IQueryable<GastoObraListInfo> ApplySort(IQueryable<GastoObraListInfo> q, string sortExpression)
        {
            switch (sortExpression)
            {
                case "numDocumento":
                    q = q.OrderBy(b => b.numDocumento);
                    break;
                case "numDocumento DESC":
                    q = q.OrderByDescending(b => b.numDocumento);
                    break;
                case "fechaEmision":
                    q = q.OrderByDescending(p=>p.numDocumento).OrderBy(b => b.fechaEmision);
                    break;
                case "fechaEmision DESC":
                    q = q.OrderByDescending(p=>p.numDocumento).OrderByDescending(b => b.fechaEmision);
                    break;
                case "proveedor":
                    q = q.OrderBy(b => b.proveedor);
                    break;
                case "proveedor DESC":
                    q = q.OrderByDescending(b => b.proveedor);
                    break;

                case "subTotal":
                    q = q.OrderBy(b => b.subTotal);
                    break;
                case "subTotal DESC":
                    q = q.OrderByDescending(b => b.subTotal);
                    break;


                case "IGVTotal":
                    q = q.OrderBy(b => b.IGVTotal);
                    break;
                case "IGVTotal DESC":
                    q = q.OrderByDescending(b => b.IGVTotal);
                    break;


                case "total":
                    q = q.OrderBy(b => b.total);
                    break;
                case "total DESC":
                    q = q.OrderByDescending(b => b.total);
                    break;


                case "numComparativo":
                    q = q.OrderBy(b => b.numComparativo);
                    break;
                case "numComparativo DESC":
                    q = q.OrderByDescending(b => b.numComparativo);
                    break;
                default:
                    q = q.OrderByDescending(b => b.fechaEmision).OrderByDescending(p => p.numDocumento);
                    break;
            }
            return q;
        }


        public IEnumerable<EstructuraOCItemInfo> getOrdenCompraSinComparativo(int idEstructuraCosto, List<Int32> utilizado)
        {
            // sin ser asigando el comparativo
            //sin estar ya  utilizado en ecitem
            var itemoc = DbUtil.Db.EstructuraCostoItems.Where(p => p.idOrdenCompraItemRef != null).Select(p => p.idOrdenCompraItemRef);

            var q1 = (from a in DbUtil.Db.OrdenCompraItems
                      where a.OrdenCompra.idEstructuraCompras == idEstructuraCosto
                      & a.OrdenCompra.idComparativo == null
                      & !itemoc.Contains(a.idInternal)
                      & !utilizado.Contains(a.idInternal)

                      select new EstructuraOCItemInfo
                      {
                          cantidad = a.cantidad.Value,
                          codigo = a.codigo,
                          descripcion = a.Descripcion,
                          unidad = a.unidad,
                          idInternal = a.idInternal,
                          precio = (a.OrdenCompra.Obra.incluyeIGV == true ? a.precioInclIGV.Value : a.precioNoIGV.Value),
                          subtotal = (a.OrdenCompra.Obra.incluyeIGV == true ? a.subMontoIGV.Value : a.subMonto.Value),
                          fecha = a.OrdenCompra.fechaEmision.Value,
                          moneda = a.OrdenCompra.moneda,
                          idOrdenCompra = a.idOrdenCompra.Value,
                          idOrdenCompraItem = a.idInternal,
                          numDocumentoOC = a.OrdenCompra.numDocumento,
                          simbol = a.OrdenCompra.Moneda1.simbol,


                      }).OrderBy(p => p.fecha);


            return q1;

        }

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraListInfo> getOrdenCompraSinRecepcion(int idAlmacen,
            int startRowIndex,
            int maximumRows,
            string sortExpression)
        {

            var q1 = (from a in DbUtil.Db.OrdenCompraItems
                      where a.OrdenCompra.idAlmacen == idAlmacen
                      & (a.OrdenCompra.idEstado == 13 | (a.OrdenCompra.idEstado == 30 & a.OrdenCompra.bitAnticipo == true))  //
                      & a.bitActivo == true
                      & (a.cantidad.Value - a.cantidadRecep.Value) > 0 &
                      a.Insumo.bitControlStock == true
                      select new OrdenCompraListInfo
                      {
                          idAlmacen=a.OrdenCompra.idAlmacen.Value,
                          idInternal = a.OrdenCompra.idInternal,
                          proveedor = a.OrdenCompra.proveedor.ToUpper(),
                          atencionEntrega = a.OrdenCompra.atencionEntrega,
                          autorizado = a.OrdenCompra.autorizado,
                          bitActivo = a.OrdenCompra.bitActivo.Value,
                          bitAnticipo = a.OrdenCompra.bitAnticipo.Value,
                          bitInclIGV = a.OrdenCompra.bitInclIGV.Value,
                          centroCosto = a.OrdenCompra.centroCosto,
                          contacProveedor = a.OrdenCompra.contacProveedor,

                          direccionEntComprobante = a.OrdenCompra.direccionEntComprobante,
                          direccionEntrega = a.OrdenCompra.direccionEntrega,
                          emisor = a.OrdenCompra.emisor,
                          estado = a.OrdenCompra.GrupoDatoitem.descripcion,
                          estructuraCosto = a.OrdenCompra.EstructuraCosto.descripcion,
                          fechaAnula = a.OrdenCompra.fechaAnula,
                          fechaCre = a.OrdenCompra.fechaCre.Value,
                          fechaEmision = a.OrdenCompra.fechaEmision.Value,
                          fechaMod = a.OrdenCompra.fechaMod.Value,
                          fechaEntrega = a.OrdenCompra.fechaPedido,
                          formaPago = a.OrdenCompra.FormaPago.descripcion,

                          idEstado = a.OrdenCompra.idEstado.Value,
                          idEstructuraCosto = a.OrdenCompra.idEstructuraCompras.Value,
                          idFormaPago = a.OrdenCompra.idFormaPago.Value,
                          idMoneda = a.OrdenCompra.idMoneda.Value,
                          idObra = a.OrdenCompra.idObra.Value,
                          idProveedor = a.OrdenCompra.idProveedor.Value,

                          idUsuarioAnula = a.OrdenCompra.idUsuarioAnula,
                          IGV = a.OrdenCompra.igv.Value,//(a.igv*100).Value.ToString("N"),
                          IGVTotal = a.OrdenCompra.IGVTotal.Value,
                          moneda = a.OrdenCompra.moneda,

                          numDocumento = a.OrdenCompra.numDocumento,
                          numDocumentoStr = String.Format("{0}-{1}", a.OrdenCompra.TipoOrden.simbol, a.OrdenCompra.numDocumento),
                          observaciones = a.OrdenCompra.observaciones,
                          simbol = a.OrdenCompra.Moneda1.simbol,
                          subTotal = a.OrdenCompra.subTotal.Value,
                          tipoCambio = a.OrdenCompra.tipoCambio.Value,
                          total = a.OrdenCompra.total.Value,
                          UsuarioCre = a.OrdenCompra.UsuarioCre.Value,
                          UsuarioMod = a.OrdenCompra.UsuarioMod.Value,
                          condicion = (a.OrdenCompra.OrdenCompraItems.Sum(p => p.cantidadRecep) == 0) ? "Total" : "Parcial",



                          //fechaContrato = a.fechaContrato.Value,
                          idComparativo = a.OrdenCompra.idComparativo == null ? 0 : a.OrdenCompra.idComparativo.Value,
                          desComparativo = a.OrdenCompra.idComparativo == null ? "" : a.OrdenCompra.Comparativo.descripcion,
                          idProveedorSelec = a.OrdenCompra.idComparativo == null ? 0 : a.OrdenCompra.idProveedorSelec.Value,
                          numComparativo = a.OrdenCompra.idComparativo == null ? "" : a.OrdenCompra.Comparativo.numDocumento,
                          tipoFormulario = (a.OrdenCompra.idTipoOrden > 1 ? "GastoObraReadForm.aspx" : "OrdenCompraReadForm.aspx"),
                      }).Distinct();



            _count = q1.Count();
            q1 = ApplySort(q1, sortExpression);
            return q1.Skip(startRowIndex).Take(maximumRows);


        }


       
        /// <summary>
        /// Ordenes de Compra pendientes de Facturar
        /// solo los que tengan el ingreso completo en  Almacen
        /// </summary>
        /// <param name="idObra"></param>
        /// <param name="startRowIndex"></param>
        /// <param name="maximumRows"></param>
        /// <param name="sortExpression"></param>
        /// <returns></returns>

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraListInfo> getOrdenCompraSinFactura(int idObra,
                                                    string proveedor, 
                                                    int startRowIndex, 
                                                    int maximumRows, 
                                                    string sortExpression)
        {

            if (!proveedor.HasValue())
                proveedor = "";
            //totdas los anticipos que aun no fueron  facturados

            var e = from r in DbUtil.Db.RecepcionDocs
                    where r.idOrdenAnticipo != null
                    select r.idOrdenAnticipo;
            var ee = from r in DbUtil.Db.OrdenAnticipos
                     where !e.Contains(r.idInternal)
                     select r;

            var q2 = (from a in DbUtil.Db.OrdenCompraItems
                      join b in ee on a.idOrdenCompra equals b.idOrden into viewObra
                        from c in viewObra.DefaultIfEmpty()
                      where
                      a.OrdenCompra.idObra == idObra
                      & a.OrdenCompra.bitActivo == true

                     & (a.OrdenCompra.idEstado == 13 | a.OrdenCompra.idEstado == 43) 
                     & (a.OrdenCompra.OrdenCompraItems.Sum(p => Convert.ToInt32(p.Insumo.bitControlStock)) == 0
                                 | (a.Insumo.bitControlStock == true & a.cantidad == a.cantidadRecep)
                                 | a.OrdenCompra.bitAnticipo== true    )
                     & ( a.OrdenCompra.proveedor.Contains(proveedor)|
                      a.OrdenCompra.docProveedor.Contains(proveedor))
                      select new OrdenCompraListInfo
                      {
                          idInternal = a.OrdenCompra.idInternal,
                          proveedor = a.OrdenCompra.Proveedor1.descripcion.ToUpper(),
                          atencionEntrega = a.OrdenCompra.atencionEntrega,
                          autorizado = a.OrdenCompra.autorizado,
                          bitActivo = a.OrdenCompra.bitActivo.Value,
                          bitInclIGV = a.OrdenCompra.bitInclIGV.Value,
                          centroCosto = a.OrdenCompra.centroCosto,
                          contacProveedor = a.OrdenCompra.contacProveedor,
                          
                          direccionEntComprobante = a.OrdenCompra.direccionEntComprobante,
                          direccionEntrega = a.OrdenCompra.direccionEntrega,
                          emisor = a.OrdenCompra.emisor,
                          estado = a.OrdenCompra.GrupoDatoitem.descripcion,
                          
                          estructuraCosto = a.OrdenCompra.idEstructuraCompras == null ? "" : a.OrdenCompra.EstructuraCosto.descripcion,
                          fechaAnula = a.OrdenCompra.fechaAnula,
                          //fechaContrato = a.fechaContrato.Value,
                          fechaCre = a.OrdenCompra.fechaCre.Value,
                            docProveedor=a.OrdenCompra.docProveedor,
                          fechaMod = a.OrdenCompra.fechaMod.Value,
                          fechaEntrega = a.OrdenCompra.fechaPedido,
                          formaPago = a.OrdenCompra.FormaPago.descripcion,
                          
                          
                          idEstado = a.OrdenCompra.idEstado.Value,
                          idEstructuraCosto = a.OrdenCompra.idEstructuraCompras,
                          idFormaPago = a.OrdenCompra.idFormaPago.Value,
                          idMoneda = a.OrdenCompra.idMoneda.Value,
                          idObra = a.OrdenCompra.idObra.Value,
                          idProveedor = a.OrdenCompra.idProveedor.Value,
                          idUsuarioAnula = a.OrdenCompra.idUsuarioAnula,
                          
                      
                          moneda = a.OrdenCompra.moneda,
                          numComparativo = a.OrdenCompra.Comparativo.numDocumento,
                          numDocumento = a.OrdenCompra.numDocumento,
                          numDocumentoStr = String.Format("{0}-{1}{2}", a.OrdenCompra.TipoOrden.simbol, a.OrdenCompra.numDocumento,(c.idInternal!=null)?"*":""),
                          observaciones = a.OrdenCompra.observaciones,
                          simbol = a.OrdenCompra.Moneda1.simbol,
                          tipoCambio = a.OrdenCompra.tipoCambio.Value,
                          UsuarioCre = a.OrdenCompra.UsuarioCre.Value,
                          UsuarioMod = a.OrdenCompra.UsuarioMod.Value,
                          //caso para mostrar los anticipos calculados
                          IGV = a.OrdenCompra.igv.Value,//(a.igv*100).Value.ToString("N"),
                          // caso de anticipos
                          fechaEmision =(c.idInternal!=null)?c.fecha: a.OrdenCompra.fechaEmision.Value,
                          subTotal = (c.idInternal != null) ? c.subTotal : a.OrdenCompra.subTotal.Value,
                          IGVTotal = (c.idInternal != null) ? c.IGVTotal : a.OrdenCompra.IGVTotal.Value,
                          total = (c.idInternal != null) ? c.total : a.OrdenCompra.total.Value,
                          idOrdenAnticipo = (c.idInternal != null) ? c.idInternal : 0,

                          desComparativo = (a.OrdenCompra.idComparativo!=null?a.OrdenCompra.Comparativo.descripcion:""),
                          idComparativo = (a.OrdenCompra.idComparativo!=null?a.OrdenCompra.idComparativo.Value:0),
                          idProveedorSelec = (a.OrdenCompra.idComparativo!=null?a.OrdenCompra.idProveedorSelec.Value:0),

                          tipoFormulario = (a.OrdenCompra.idTipoOrden > 1 ? "GastoObraReadForm.aspx" : "OrdenCompraReadForm.aspx"),
                        
                      }).Distinct();
            _count = q2.Count();
            q2 = ApplySort(q2, sortExpression);

            
            return q2.Skip(startRowIndex).Take(maximumRows);
               
          

        }


        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraListInfo> getOrdenCompraSinFactura(int idObra,
                                                      int startRowIndex,
                                                    int maximumRows,
                                                    string sortExpression)
        {

            
            //totdas los anticipos que aun no fueron  facturados

            var e = from r in DbUtil.Db.RecepcionDocs
                    where r.idOrdenAnticipo != null
                    select r.idOrdenAnticipo;
            var ee = from r in DbUtil.Db.OrdenAnticipos
                     where !e.Contains(r.idInternal)
                     select r;

            var q2 = (from a in DbUtil.Db.OrdenCompraItems
                      join b in ee on a.idOrdenCompra equals b.idOrden into viewObra
                      from c in viewObra.DefaultIfEmpty()
                      where
                      a.OrdenCompra.idObra == idObra
                      & a.OrdenCompra.bitActivo == true

                     & (a.OrdenCompra.idEstado == 13 | a.OrdenCompra.idEstado == 43)
                     & (a.OrdenCompra.OrdenCompraItems.Sum(p => Convert.ToInt32(p.Insumo.bitControlStock)) == 0
                                 | (a.Insumo.bitControlStock == true & a.cantidad == a.cantidadRecep)
                                 | a.OrdenCompra.bitAnticipo == true)
                    
                      select new OrdenCompraListInfo
                      {
                          idInternal = a.OrdenCompra.idInternal,
                          proveedor = a.OrdenCompra.Proveedor1.descripcion.ToUpper(),
                          atencionEntrega = a.OrdenCompra.atencionEntrega,
                          autorizado = a.OrdenCompra.autorizado,
                          bitActivo = a.OrdenCompra.bitActivo.Value,
                          bitInclIGV = a.OrdenCompra.bitInclIGV.Value,
                          centroCosto = a.OrdenCompra.centroCosto,
                          contacProveedor = a.OrdenCompra.contacProveedor,

                          direccionEntComprobante = a.OrdenCompra.direccionEntComprobante,
                          direccionEntrega = a.OrdenCompra.direccionEntrega,
                          emisor = a.OrdenCompra.emisor,
                          estado = a.OrdenCompra.GrupoDatoitem.descripcion,
                          docProveedor = a.OrdenCompra.docProveedor,
                          estructuraCosto = a.OrdenCompra.idEstructuraCompras == null ? "" : a.OrdenCompra.EstructuraCosto.descripcion,
                          fechaAnula = a.OrdenCompra.fechaAnula,
                          //fechaContrato = a.fechaContrato.Value,
                          fechaCre = a.OrdenCompra.fechaCre.Value,

                          fechaMod = a.OrdenCompra.fechaMod.Value,
                          fechaEntrega = a.OrdenCompra.fechaPedido,
                          formaPago = a.OrdenCompra.FormaPago.descripcion,


                          idEstado = a.OrdenCompra.idEstado.Value,
                          idEstructuraCosto = a.OrdenCompra.idEstructuraCompras,
                          idFormaPago = a.OrdenCompra.idFormaPago.Value,
                          idMoneda = a.OrdenCompra.idMoneda.Value,
                          idObra = a.OrdenCompra.idObra.Value,
                          idProveedor = a.OrdenCompra.idProveedor.Value,
                          idUsuarioAnula = a.OrdenCompra.idUsuarioAnula,


                          moneda = a.OrdenCompra.moneda,
                          numComparativo = a.OrdenCompra.Comparativo.numDocumento,
                          numDocumento = a.OrdenCompra.numDocumento,
                          numDocumentoStr = String.Format("{0}-{1}{2}", a.OrdenCompra.TipoOrden.simbol, a.OrdenCompra.numDocumento, (c.idInternal != null) ? "*" : ""),
                          observaciones = a.OrdenCompra.observaciones,
                          simbol = a.OrdenCompra.Moneda1.simbol,
                          tipoCambio = a.OrdenCompra.tipoCambio.Value,
                          UsuarioCre = a.OrdenCompra.UsuarioCre.Value,
                          UsuarioMod = a.OrdenCompra.UsuarioMod.Value,
                          //caso para mostrar los anticipos calculados
                          IGV = a.OrdenCompra.igv.Value,//(a.igv*100).Value.ToString("N"),
                          // caso de anticipos
                          fechaEmision = (c.idInternal != null) ? c.fecha : a.OrdenCompra.fechaEmision.Value,
                          subTotal = (c.idInternal != null) ? c.subTotal : a.OrdenCompra.subTotal.Value,
                          IGVTotal = (c.idInternal != null) ? c.IGVTotal : a.OrdenCompra.IGVTotal.Value,
                          total = (c.idInternal != null) ? c.total : a.OrdenCompra.total.Value,
                          idOrdenAnticipo = (c.idInternal != null) ? c.idInternal : 0,

                          desComparativo = (a.OrdenCompra.idComparativo != null ? a.OrdenCompra.Comparativo.descripcion : ""),
                          idComparativo = (a.OrdenCompra.idComparativo != null ? a.OrdenCompra.idComparativo.Value : 0),
                          idProveedorSelec = (a.OrdenCompra.idComparativo != null ? a.OrdenCompra.idProveedorSelec.Value : 0),

                          tipoFormulario = (a.OrdenCompra.idTipoOrden > 1 ? "GastoObraReadForm.aspx" : "OrdenCompraReadForm.aspx"),

                      }).Distinct();
            _count = q2.Count();
            q2 = ApplySort(q2, sortExpression);


            return q2.Skip(startRowIndex).Take(maximumRows);



        }

         [DataObjectMethod(DataObjectMethodType.Select, false)]
        public bool EsOrdenSinRecepcion(int idOrden)
        {
            bool result = false;

            //referencia -->this.getOrdenCompraSinRecepcion

            var q = from a in DbUtil.Db.OrdenCompraItems
                    where a.idOrdenCompra == idOrden
                    & (a.OrdenCompra.idEstado == 13) //aprobado  |a.OrdenCompra.idEstado==30
                    & a.bitActivo == true
                    & (a.cantidad.Value - a.cantidadRecep.Value) > 0 &
                    a.Insumo.bitControlStock == true
                    select a;
            if (q.Count() > 0)
            {
                result = true;
            }

            return result;
        }


         [DataObjectMethod(DataObjectMethodType.Select, false)]
         public bool EsOrdenSinFacturar(int idOrden)
         {
             bool result = false;

             //referencia -->this.getOrdenCompraSinRecepcion

             var q = from a in DbUtil.Db.OrdenCompraItems
                     where a.OrdenCompra.idInternal == idOrden
                     & a.OrdenCompra.bitActivo == true
                    & a.OrdenCompra.idEstado == 13 &
                   (a.OrdenCompra.OrdenCompraItems.Sum(p => Convert.ToInt32(p.Insumo.bitControlStock)) == 0
                    | (a.Insumo.bitControlStock == true & a.cantidad == a.cantidadRecep))
                     select a;
             if (q.Count() > 0)
             {
                 result = true;
             }

             return result;
         }

       



        /// <summary>
        /// Ordenes de Compra pendientes de Aprobacion 
        /// </summary>
        /// <param name="idObra"></param>
        /// <param name="startRowIndex"></param>
        /// <param name="maximumRows"></param>
        /// <param name="sortExpression"></param>
        /// <returns></returns>

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraListInfo> getOrdenCompraSinAprobar(int idObra, int startRowIndex, int maximumRows, string sortExpression)
        {



            var q2 = from a in DbUtil.Db.OrdenCompras
                     where a.idObra == idObra
                     & a.idEstado==11
                     //& a.idTipoOrden==1
                     select new OrdenCompraListInfo
                     {
                         idInternal = a.idInternal,
                         proveedor = a.proveedor.ToUpper(),
                         atencionEntrega = a.atencionEntrega,
                         autorizado = a.autorizado,
                         bitActivo = a.bitActivo.Value,
                         bitInclIGV = a.bitInclIGV.Value,
                         centroCosto = a.centroCosto,
                         contacProveedor = a.contacProveedor,
                         
                         direccionEntComprobante = a.direccionEntComprobante,
                         direccionEntrega = a.direccionEntrega,
                         emisor = a.emisor,
                         estado = a.GrupoDatoitem.descripcion,
                         estructuraCosto = a.idEstructuraCompras == null ? "" : a.EstructuraCosto.descripcion,
                         fechaAnula = a.fechaAnula,
                         
                         fechaCre = a.fechaCre.Value,
                         fechaEmision = a.fechaEmision.Value,
                         fechaMod = a.fechaMod.Value,
                         fechaEntrega = a.fechaPedido,
                         formaPago = a.FormaPago.descripcion,
                         
                         idEstado = a.idEstado.Value,
                         idEstructuraCosto = a.idEstructuraCompras,
                         idFormaPago = a.idFormaPago.Value,
                         idMoneda = a.idMoneda.Value,
                         idObra = a.idObra.Value,
                         idProveedor = a.idProveedor.Value,
                         
                         idUsuarioAnula = a.idUsuarioAnula,
                         IGV = a.igv.Value,//(a.igv*100).Value.ToString("N"),
                         IGVTotal = a.IGVTotal.Value,
                         moneda = a.moneda,
                         
                         numDocumento = a.numDocumento,
                         observaciones = a.observaciones,
                         simbol = a.Moneda1.simbol,
                         subTotal = a.subTotal.Value,
                         tipoCambio = a.tipoCambio.Value,
                         total = a.total.Value,
                         UsuarioCre = a.UsuarioCre.Value,
                         UsuarioMod = a.UsuarioMod.Value  ,

                         
                         //fechaContrato = a.fechaContrato.Value,
                         idComparativo =a.idComparativo==null? 0: a.idComparativo.Value,
                         desComparativo = a.idComparativo==null? "":a.Comparativo.descripcion,
                         idProveedorSelec =a.idComparativo==null? 0:a.idProveedorSelec.Value,
                         numComparativo = a.idComparativo==null? "":a.Comparativo.numDocumento,
                         tipoFormulario = (a.idTipoOrden > 1 ? "GastoObraReadForm.aspx" : "OrdenCompraReadForm.aspx"),
                     };
            _count = q2.Count();
            q2 = ApplySort(q2, sortExpression);
            return q2.Skip(startRowIndex).Take(maximumRows);



        }





        int _count;
                                                                    


            public int Counta(int idOrden,
                                                                    int startRowIndex, 
                                                                    int maximumRows, 
                                                                    string sortExpression)
                        {
                            return _count;
                        }


            public int Count(int startRowIndex,
                             int maximumRows,
                             string sortExpression)
            {
                return _count;
            }

            public int Count(int idObra,
                                      string proveedor,
                                      int startRowIndex,
                                      int maximumRows,
                                      string sortExpression)
            {
                return _count;
            }

        public int Count(int idObra, int startRowIndex, int maximumRows, string sortExpression)
        {
            return _count;
        }

        public int Countg(int idObra,
                        string numDocumentoStr,
                        string proveedorStr,        
                        int idTipoOrden,
                        DateTime fechaInicio, 
                        DateTime fechaFin, 
                        int startRowIndex,
                        int maximumRows, 
                        string sortExpression)
        {
            return _count;
        }


        public int Count(int idtipo, int idRendicion, int startRowIndex, int maximumRows, string sortExpression)
        {
            return _count;
        }

        public int Count(int startRowIndex, int maximumRows, string sortExpression, int idAlmacen)
        {
            return _count;
        }
        public int Count(int idObra,
             bool bitVerAnula,
            string numDocumentoStr,
             string estadoStr,
             string proveedorStr,
             DateTime? fechaInicio,
             DateTime? fechaFin,
             int startRowIndex,
             int maximumRows,
             string sortExpression)
        {
            return _count;
        }
        public int Count(int idObra,  bool bitVerAnula,DateTime fechaInicio, DateTime fechaFin, int startRowIndex, int maximumRows, string sortExpression)
        {
            return _count;
        }
        public int Count(int idComparativo, int startRowIndex, int maximumRows, string sortExpression,int idObra)
        {
            return _count;
        }


        public int CountEC(int idEstructuraCosto, int startRowIndex, int maximumRows, string sortExpression, int idObra)
        {
            return _count;
        }


        public int Countc(int idComparativo, int startRowIndex, int maximumRows, string sortExpression)
        {
            return _count;
        }
        public int Countc(int idComparativo, int idObra, int startRowIndex, int maximumRows, string sortExpression)
        {
            return _count;
        }
        public int Count(int idObra, DateTime fechaInicio, DateTime fechaFin, int startRowIndex, int maximumRows,
                            string sortExpression)
        {
            return _count;
        }





         [DataObjectMethod(DataObjectMethodType.Select, false)]
         public IEnumerable<OrdenCompraListInfo> getOrdenCompraFiltroList(int idObra,
             bool bitVerAnula,
             string numDocumentoStr,
             string estadoStr,
             string proveedorStr,
             DateTime? fechaInicio,
             DateTime? fechaFin,
             int startRowIndex,
             int maximumRows,
             string sortExpression)
         {
             if (!proveedorStr.HasValue())
                 proveedorStr = "";

             if (!numDocumentoStr.HasValue())
                 numDocumentoStr = "";

             

             var q = ApplySelect_OrdenCompraListInfo();

             if (estadoStr == "0") //todos
             {
                 q = q.Where(a => a.idObra == idObra &
                 a.fechaEmision > fechaInicio &
                 a.fechaEmision < fechaFin.Value.AddDays(1)
                  & (a.bitActivo == true | a.bitActivo == !bitVerAnula)
                 & a.idTipoOrden == 1
                 & a.proveedor.Contains(proveedorStr)
                 & a.numDocumento.Contains(numDocumentoStr)
                 );
             }
            
             if (estadoStr != "0") //pendientes
             {
                 q = q.Where(a => a.idObra == idObra &
                     a.fechaEmision > fechaInicio &
                     a.fechaEmision < fechaFin.Value.AddDays(1)
                     & (a.bitActivo == true | a.bitActivo == !bitVerAnula)
                     & a.idTipoOrden == 1
                     & a.proveedor.Contains(proveedorStr)
                     & a.idEstado == Convert.ToInt32(estadoStr)
                     & a.numDocumento.Contains(numDocumentoStr)
                     );
             }


             _count = q.Count();

             q = ApplySort(q, sortExpression);
             return q.Skip(startRowIndex).Take(maximumRows).ToList();
         }









        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraListInfo> getOrdenCompraList(int idObra,
            bool bitVerAnula, 
            DateTime fechaInicio, 
            DateTime fechaFin, 
            int startRowIndex, 
            int maximumRows, 
            string sortExpression)

        {


            var q = ApplySelect_OrdenCompraListInfo();


            q = q.Where(a => a.idObra == idObra
                & a.fechaEmision >= fechaInicio & a.fechaEmision < fechaFin.AddDays(1)
                                    & (a.bitActivo == true | a.bitActivo == !bitVerAnula)
                                    & a.idTipoOrden==1
                                    );
           
            
            
            _count = q.Count();
            q = ApplySort(q, sortExpression);
            return q.Skip(startRowIndex).Take(maximumRows).ToList();

        }


        
        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<GastoObraListInfo> getGastoObraList(
            int idTipoOrden,
            int idObra,
            string numDocumentoStr,
            string     proveedorStr,
            DateTime fechaInicio, 
            DateTime fechaFin, 
            int startRowIndex, 
            int maximumRows, 
            string sortExpression)

        {

            if (!proveedorStr.HasValue())
                proveedorStr = "";
            if(!numDocumentoStr.HasValue())
                numDocumentoStr="";


            var q = ApplySelect_GastoObraListInfo();
            q = q.Where(a => a.idObra == idObra
                        & a.numDocumento.Contains(numDocumentoStr)
                        & a.proveedor.Contains(proveedorStr)
                        & a.fechaEmision >= fechaInicio & a.fechaEmision < fechaFin.AddDays(1)
                                    & (idTipoOrden == 0 ? (a.idTipoOrden > 1) : a.idTipoOrden == idTipoOrden)
                                    );
           
            
            
            _count = q.Count();
            q = ApplySort(q, sortExpression);
            return q.Skip(startRowIndex).Take(maximumRows).ToList();

        }



        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<GastoObraListInfo> getGastoObraList(
            int startRowIndex,             
            int maximumRows,
               int idComparativo,
            string sortExpression)
        {
            var q = ApplySelect_GastoObraListInfo();
            q = q.Where(a => a.idComparativo == idComparativo 
               & a.idTipoOrden > 1);

            _count = q.Count();
            q = ApplySort(q, sortExpression);
            return q.Skip(startRowIndex).Take(maximumRows).ToList();

        }


         [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<GastoObraListInfo> getGastoObraList(int  idtipo,
            int startRowIndex,
              int idRendicion,
            int maximumRows,
             string sortExpression)
        {
            var q = ApplySelect_GastoObraListInfo();
            q = q.Where(a => a.idRendicion == idRendicion 
               & a.idTipoOrden > 1);

            _count = q.Count();
            q = ApplySort(q, sortExpression);
            return q.Skip(startRowIndex).Take(maximumRows).ToList();

        }

        

        [DataObjectMethod(DataObjectMethodType.Select, false)]
         public IEnumerable<OrdenCompraListInfo> getOrdenCompraListEC(int idEstructuraCosto,
                                                                    int idObra,
                                                                    int startRowIndex, 
                                                                    int maximumRows, 
                                                                    string sortExpression)
        {

            var q = ApplySelect_OrdenCompraListInfo();
            q = q.Where(a => a.idEstructuraCosto == idEstructuraCosto &  a.idObra == idObra);
            _count = q.Count();
           
            
            q = ApplySort(q, sortExpression);
            return q.Skip(startRowIndex).Take(maximumRows).ToList();

          


        }


        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraListInfo> getOrdenCompraList(int idComparativo,
            int idObra, int startRowIndex, int maximumRows, string sortExpression)
        {

            var q = ApplySelect_OrdenCompraListInfo();
            q = q.Where(a => a.idComparativo == idComparativo & a.idTipoOrden == 1 & a.idObra == idObra);
            _count = q.Count();


            q = ApplySort(q, sortExpression);
            return q.Skip(startRowIndex).Take(maximumRows).ToList();




        }
      


          [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenAnticipoInfo> getOrdenAnticipoList(int idOrden,
                                                                    int startRowIndex, 
                                                                    int maximumRows, 
                                                                    string sortExpression)
        {

                                   var q= from a in DbUtil.Db.OrdenAnticipos
                                   where a.idOrden==idOrden
                                   select new OrdenAnticipoInfo
                                   {
                                       idObra=a.OrdenCompra.idObra.Value,
                                       descripcion=a.descripcion,
                                       fecha=a.fecha,
                                       fechaStr=a.fecha.ToShortDateString(),
                                       idInternal=a.idInternal,
                                       idOrden=a.idOrden,
                                       porcentaje=a.porcentaje,
                                       totalStr=string.Format("{0} {1:N}",a.OrdenCompra.Moneda1.simbol,a.total),
                                       IGVStr = string.Format("{0} {1:N}", a.OrdenCompra.Moneda1.simbol, a.IGVTotal),
                                       subTotalStr = string.Format("{0} {1:N}", a.OrdenCompra.Moneda1.simbol, a.subTotal),
                                       total=a.total
                                   };


            _count = q.Count();
           
            
            q = ApplySort(q, sortExpression);
            return q.Skip(startRowIndex).Take(maximumRows).ToList();

          


        }

        public List<OrdenCompraItemInfo> getOrdenCompraItem(dbGestionDataContext _db,int idOrdenCompra)
        {

              DAL.Menu insumoRead = DbUtil.Db.Menus.Single(p => p.idInternal == 123);

             
            var q = from a in _db.OrdenCompraItems
                    where a.idOrdenCompra == idOrdenCompra
                    select new OrdenCompraItemInfo(a.idInternal, 
                                                    a.idInsumo.Value, 
                                                    a.idOrdenCompra.Value, 
                                                    a.Descripcion, 
                                                    a.unidad, 
                                                    a.codigo,
                                                    a.idComparativoItemSelecPrv, 
                                                    a.bitActivo.Value, 
                                                    a.cantidad.Value, 
                                                    a.subMonto.Value,
                                                    a.subMontoIGV.Value, 
                                                    a.precioInclIGV.Value,
                                                    a.precioNoIGV.Value, 
                                                    a.IGVItem.Value, 
                                                    a.descuento.Value,
                                                    string.Format("javascript:loadTabFromForm('tab{0}','{1}','{2}?id={3}');",
                                                                insumoRead.idAplicacion,
                                                                insumoRead.Aplicacion.title,
                                                                insumoRead.url,
                                                                a.idInsumo));
                    

            return q.ToList();

        }

        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraMensajeInfo> GetOrdenCompraMensajeList(int idOrden)
        {
            var q = from a in DbUtil.Db.MensajeEmails
                    where a.idOrden == idOrden
                    select new OrdenCompraMensajeInfo
                   {
                        archivo=a.archivo,
                        Asunto=a.Asunto,
                        cc=a.cc,
                        cco=a.cco,
                        desde=a.desde,
                        destinatario=a.destinatario,
                        fechaCre=a.fechaCre,
                        fechaCreStr=a.fechaCre.ToShortDateString(),
                        idInternal=a.idInternal,
                        idOrden=a.idOrden.Value,
                        mensaje=a.mensaje
                        
                    };

            return q.OrderByDescending(p=>p.fechaCre);

        }

        public IQueryable<OrdenCompraListInfo> ApplySelect_OrdenCompraListInfo()
        {
            DAL.Menu ordenCompraaRead = DbUtil.Db.Menus.Single(p => p.idInternal == 106);
            DAL.Menu gastoObraRead = DbUtil.Db.Menus.Single(p => p.idInternal == 107);


            var q = from a in DbUtil.Db.OrdenCompras
                    select new OrdenCompraListInfo
                    {
                        idTipoOrden=a.idTipoOrden.Value,
                        idInternal = a.idInternal,
                        proveedor = a.proveedor.ToUpper(),
                        atencionEntrega = a.atencionEntrega,
                        autorizado = a.autorizado,
                        bitActivo = a.bitActivo.Value,
                        bitInclIGV = a.bitInclIGV.Value,
                        centroCosto = a.centroCosto,
                        contacProveedor = a.contacProveedor,
                        
                        direccionEntComprobante = a.direccionEntComprobante,
                        direccionEntrega = a.direccionEntrega,
                        emisor = a.emisor,
                        estado = a.GrupoDatoitem.descripcion,
                        
                        estructuraCosto = a.idEstructuraCompras == null ? "" : a.EstructuraCosto.descripcion,
                        fechaAnula = a.fechaAnula,
                        
                        fechaCre = a.fechaCre.Value,
                        fechaEmision = a.fechaEmision.Value,
                        fechaMod = a.fechaMod.Value,
                        fechaEntrega = a.fechaPedido,
                        formaPago = a.FormaPago.descripcion,
                        
                        idEstado = a.idEstado.Value,
                        idEstructuraCosto = a.idEstructuraCompras,
                        idFormaPago = a.idFormaPago.Value,
                        idMoneda = a.idMoneda.Value,
                        idObra = a.idObra.Value,
                        
                        idProveedor = a.idProveedor.Value,
                        
                        idUsuarioAnula = a.idUsuarioAnula,
                        IGV = a.igv.Value,
                        IGVTotal = a.IGVTotal.Value,
                        moneda = a.moneda,
                        numDocumentoStr = String.Format("{0}-{1}", a.TipoOrden.simbol, a.numDocumento),
                        numDocumento = a.numDocumento,
                        observaciones = a.observaciones,
                        simbol = a.Moneda1.simbol,
                        subTotal = a.subTotal.Value,
                        tipoCambio = a.tipoCambio.Value,
                        total = a.total.Value,
                        UsuarioCre = a.UsuarioCre.Value,
                        UsuarioMod = a.UsuarioMod.Value,
                        bitAnticipo=a.bitAnticipo.Value ,
                        obraStr=a.Obra.descripcion,
                        numComparativo = (a.idComparativo == null) ? "" : a.Comparativo.numDocumento,
                        desComparativo =(a.idComparativo==null)?"" : a.Comparativo.descripcion,
                        //fechaContrato = a.fechaContrato.Value,
                        idComparativo =   (a.idComparativo == null)? 0 : a.idComparativo.Value,
                        idProveedorSelec =(a.idComparativo == null) ? 0 : a.idProveedorSelec.Value,
                        tipoFormulario = (a.idTipoOrden > 1 ? "GastoObraReadForm.aspx" : "OrdenCompraReadForm.aspx"),
                        typePrint = (a.idTipoOrden > 1 ? "GASTOOBRA":"OC"),
                       
                        //----------TAB-> tab(idpplicacion-id)
                       formulario = string.Format("javascript:loadTabFromForm('tab{0}-{1}','{2}','{3}?id={4}&idObra={1}');",
                                ordenCompraaRead.idAplicacion,
                                a.idObra,
                                a.Obra.descripcion,
                                (a.idTipoOrden > 1 ? gastoObraRead.url : ordenCompraaRead.url),
                                a.idInternal),
                        //-------------------------------
                    };
            return q;
        }

        private IQueryable<GastoObraListInfo> ApplySelect_GastoObraListInfo()
        {
            var q = from a in DbUtil.Db.OrdenCompras
                    select new GastoObraListInfo
                    {
                        idTipoOrden = a.idTipoOrden.Value,
                        idInternal = a.idInternal,
                        proveedor = a.proveedor,
                        
                        estado = a.GrupoDatoitem.descripcion,
                        
                        estructuraCosto = a.idEstructuraCompras == null ? "" : a.EstructuraCosto.descripcion,
                        
                        fechaCre = a.fechaCre.Value,
                        fechaEmision = a.fechaEmision.Value,
                        fechaMod = a.fechaMod.Value,
                        formaPago = a.FormaPago.descripcion,
                        
                        idEstado = a.idEstado.Value,
                        idEstructuraCosto = a.idEstructuraCompras,
                        idFormaPago = a.idFormaPago.Value,
                        idMoneda = a.idMoneda.Value,
                        idObra = a.idObra.Value,
                        idProveedor = a.idProveedor.Value,
                        
                        IGV = a.igv.Value,
                        IGVTotal = a.IGVTotal.Value,
                        moneda = a.moneda,
                        
                        numDocumento = a.numDocumento,
                        numDocumentoStr = String.Format("{0}-{1}", a.TipoOrden.simbol, a.numDocumento),

                        observaciones = a.observaciones,
                        subTotal = a.subTotal.Value,
                        tipoCambio = a.tipoCambio.Value,
                        total = a.total.Value,
                        UsuarioCre = a.UsuarioCre.Value,
                        UsuarioMod = a.UsuarioMod.Value,

                        
                        numComparativo = (a.idComparativo == null) ? "" : a.Comparativo.numDocumento,
                        desComparativo = (a.idComparativo == null) ? "" : a.Comparativo.descripcion,
                        //fechaContrato = a.fechaContrato.Value,
                        idComparativo = (a.idComparativo == null) ? 0 : a.idComparativo.Value,
                        idProveedorSelec = (a.idComparativo == null) ? 0 : a.idProveedorSelec.Value,


                        totalMon=String.Format("{0} {1:N}",a.Moneda1.simbol,a.total.Value),
                        IGVTotalMon=String.Format("{0} {1:N}",a.Moneda1.simbol,a.IGVTotal.Value),
                        subTotalMon=String.Format("{0} {1:N}",a.Moneda1.simbol,a.subTotal)  ,
                               idRendicion=a.idRendicion,
                        
                    };
            return q;
        }
        #endregion


        [DataObjectMethod(DataObjectMethodType.Select, false)]
        public IEnumerable<OrdenCompraListInfo> getOrdenCompraSinCOMPResuList(int startRowIndex,
                                                                                    int maximumRows,
                                                                                    string sortExpression)
        {



            var q2 = this.GetOrdenCompraSinCompResu();


            _count = q2.Count();
            q2 = ApplySort(q2, sortExpression);


            q2 = q2.Skip(startRowIndex).Take(maximumRows);

            return q2;
        }


        private IQueryable<OrdenCompraListInfo> GetOrdenCompraSinCompResu()
        {


            int? i = (int?)System.Web.HttpContext.Current.Session["idEmpleado"];
            if (i == null)
                return null;

            int idEmpleado = int.Parse(System.Web.HttpContext.Current.Session["idEmpleado"].ToString());
            

            var obr = from x in DbUtil.Db.EmpleadoObras
                      where x.idEmpleado == idEmpleado 
                      select new
                      {
                          idInternal = x.Obra.idInternal,
                          descripcion = x.Obra.descripcion,
                          proyecto = x.Obra.Proyecto.descripcion
                      };

            var habiObra = from x in DbUtil.Db.EmpleadoObras
                           where x.idEmpleado == idEmpleado 
                           select x.idObra;




            var q2 = from a in DbUtil.Db.OrdenCompras
                     join b in obr on a.idObra equals b.idInternal into viewObra
                     from c in viewObra.DefaultIfEmpty()
                     where
                     (a.idEstado == 11 )
                     & a.idComparativo ==null
                     & (habiObra.Contains(a.idObra.Value) | a.idObra == null)
                     select new OrdenCompraListInfo
                     {
                         idInternal = a.idInternal,
                         idObra = a.idObra.Value,
                         numDocumento=a.numDocumento,
                         fechaEmision = a.fechaEmision.Value,
                         proveedor = a.Proveedor1.descripcion,
                         simbol = a.Moneda1.simbol,
                         total = a.total.Value     ,
                         IGVTotal= a.IGVTotal.Value ,
                         subTotal = a.subTotal.Value,
                         obraStr = a.Obra.descripcion,
                         tipoFormulario = (a.idTipoOrden > 1 ? "GastoObraReadForm.aspx" : "OrdenCompraReadForm.aspx"),
                         formulario=string.Format("javascript:loadTabFromForm('tab{0}-{1}','{2}','{3}?id={4}&idObra={1}');",
                                                ordenCompraRead.idAplicacion,
                                                a.idObra,
                                                a.Obra.descripcion,
                                                (a.idTipoOrden!=1?ordenGastoRead.url:ordenCompraRead.url),
                                                a.idInternal)
                     };
            return q2;
        }


        public OrdenCompraItemInfo GetOrdenCompraItemFromValor(dbGestionDataContext _db,
                                                                   int idInsumo,
                                                                  decimal cantidad,
                                                                  decimal IGVvalor,
                                                                  bool PrecioIGVIncluye,
                                                                  bool CalcularIGV,
                                                                  decimal precio,
                                                                  decimal subtotal)
        {

            var insumo = _db.Insumos.Single(p => p.idInternal == idInsumo);
            decimal precioIGV = 0;
            decimal precioSinIGV = 0;
            decimal subTotalIGV = 0;
            decimal subtotalSinIGV = 0;
            //si incluye iGV
            if (!PrecioIGVIncluye)
            {
                decimal subTotalCal = subtotal * (1 + (IGVvalor / 100));
                //calculamos los que quedan
                precioIGV = (subTotalCal / cantidad);
                subTotalIGV = subTotalCal;
            }
            else
            {
                decimal subTotalCal = subtotal / (1 + IGVvalor / 100);
                //calculamos los que quedan
                precioSinIGV = (subTotalCal / cantidad);
                subtotalSinIGV = subTotalCal;
            }


            if (!CalcularIGV)
            {
                //si no calcula el IGV se igualan montos
                if (!PrecioIGVIncluye)
                {
                    decimal subTotalCal = subtotal ;
                    //calculamos los que quedan
                    //precioIGV = (subTotalCal / cantidad);
                    subTotalIGV = subTotalCal;
                }
                else
                {
                    decimal subTotalCal = subtotal;
                    //calculamos los que quedan
                    //precioSinIGV = (subTotalCal / cantidad);
                    subtotalSinIGV = subTotalCal;
                }
            }
              DAL.Menu insumoRead = DbUtil.Db.Menus.Single(p => p.idInternal == 123);

            var ordenCompraItemInfo = new OrdenCompraItemInfo(Parametros.GenerarID(),
                                                              insumo.idInternal,
                                                              0,
                                                              insumo.descripcion,
                                                              insumo.InsumoUnidad.abreviacion,
                                                              insumo.codigo,
                                                              0,
                                                              true,
                                                              cantidad,
                                                              PrecioIGVIncluye == true ? subtotalSinIGV : subtotal,    //submonto
                                                              PrecioIGVIncluye == true ? subtotal : subTotalIGV,  //submontoIGV
                                                              PrecioIGVIncluye == true ? precio : precioIGV,         //precioIGV
                                                              PrecioIGVIncluye == true ? precioSinIGV : precio,     // precio
                                                              IGVvalor,
                                                              0,
                                                              string.Format("javascript:loadTabFromForm('tab{0}','{1}','{2}?id={3}');",
                                                                insumoRead.idAplicacion,
                                                                insumoRead.Aplicacion.title,
                                                                insumoRead.url,
                                                                insumo.idInternal));

            return ordenCompraItemInfo;
        }



        

    }
   

   


   



}
